import.meta.location 0.0.0

package/dist/plugin/index.d.mts

@@ -0,0 +1,2571 @@
+import { PluginObj, PluginPass } from "@babel/core";
+
+//#region \0rolldown/runtime.js
+declare namespace index_legacy_d_exports {
+  export { Accessor, Aliases, AnyTypeAnnotation, ArgumentPlaceholder, ArrayExpression, ArrayPattern, ArrayTypeAnnotation, ArrowFunctionExpression, AssignmentExpression, AssignmentPattern, AwaitExpression, BigIntLiteral, Binary, BinaryExpression, BindExpression, Block, BlockParent, BlockStatement, BooleanLiteral, BooleanLiteralTypeAnnotation, BooleanTypeAnnotation, BreakStatement, CallExpression, CatchClause, Class, ClassAccessorProperty, ClassBody, ClassDeclaration, ClassExpression, ClassImplements, ClassMethod, ClassPrivateMethod, ClassPrivateProperty, ClassProperty, Comment, CommentBlock, CommentLine, CommentTypeShorthand, CompletionStatement, Conditional, ConditionalExpression, ContinueStatement, DebuggerStatement, DecimalLiteral, Declaration, DeclareClass, DeclareExportAllDeclaration, DeclareExportDeclaration, DeclareFunction, DeclareInterface, DeclareModule, DeclareModuleExports, DeclareOpaqueType, DeclareTypeAlias, DeclareVariable, DeclaredPredicate, Decorator, Directive, DirectiveLiteral, DoExpression, DoWhileStatement, EmptyStatement, EmptyTypeAnnotation, EnumBody, EnumBooleanBody, EnumBooleanMember, EnumDeclaration, EnumDefaultedMember, EnumMember, EnumNumberBody, EnumNumberMember, EnumStringBody, EnumStringMember, EnumSymbolBody, ExistsTypeAnnotation, ExportAllDeclaration, ExportDeclaration, ExportDefaultDeclaration, ExportDefaultSpecifier, ExportNamedDeclaration, ExportNamespaceSpecifier, ExportSpecifier, Expression, ExpressionStatement, ExpressionWrapper, File, Flow, FlowBaseAnnotation, FlowDeclaration, FlowPredicate, FlowType, For, ForInStatement, ForOfStatement, ForStatement, ForXStatement, Function, FunctionDeclaration, FunctionExpression, FunctionParameter, FunctionParent, FunctionTypeAnnotation, FunctionTypeParam, GenericTypeAnnotation, Identifier, IfStatement, Immutable, Import, ImportAttribute, ImportDeclaration, ImportDefaultSpecifier, ImportExpression, ImportNamespaceSpecifier, ImportOrExportDeclaration, ImportSpecifier, IndexedAccessType, InferredPredicate, InterfaceDeclaration, InterfaceExtends, InterfaceTypeAnnotation, InterpreterDirective, IntersectionTypeAnnotation, JSX, JSXAttribute, JSXClosingElement, JSXClosingFragment, JSXElement, JSXEmptyExpression, JSXExpressionContainer, JSXFragment, JSXIdentifier, JSXMemberExpression, JSXNamespacedName, JSXOpeningElement, JSXOpeningFragment, JSXSpreadAttribute, JSXSpreadChild, JSXText, LVal, LabeledStatement, Literal, LogicalExpression, Loop, MemberExpression, MetaProperty, Method, Miscellaneous, MixedTypeAnnotation, ModuleDeclaration, ModuleExpression, ModuleSpecifier, NewExpression, Node, Noop, NullLiteral, NullLiteralTypeAnnotation, NullableTypeAnnotation, NumberLiteral, NumberLiteralTypeAnnotation, NumberTypeAnnotation, NumericLiteral, ObjectExpression, ObjectMember, ObjectMethod, ObjectPattern, ObjectProperty, ObjectTypeAnnotation, ObjectTypeCallProperty, ObjectTypeIndexer, ObjectTypeInternalSlot, ObjectTypeProperty, ObjectTypeSpreadProperty, OpaqueType, OptionalCallExpression, OptionalIndexedAccessType, OptionalMemberExpression, ParenthesizedExpression, Pattern, PatternLike, PipelineBareFunction, PipelinePrimaryTopicReference, PipelineTopicExpression, Placeholder, Private, PrivateName, Program, Property, Pureish, QualifiedTypeIdentifier, RecordExpression, RegExpLiteral, RegexLiteral, RestElement, RestProperty, ReturnStatement, Scopable, SequenceExpression, SourceLocation, SpreadElement, SpreadProperty, Standardized, Statement, StaticBlock, StringLiteral, StringLiteralTypeAnnotation, StringTypeAnnotation, Super, SwitchCase, SwitchStatement, SymbolTypeAnnotation, TSAnyKeyword, TSArrayType, TSAsExpression, TSBaseType, TSBigIntKeyword, TSBooleanKeyword, TSCallSignatureDeclaration, TSConditionalType, TSConstructSignatureDeclaration, TSConstructorType, TSDeclareFunction, TSDeclareMethod, TSEntityName, TSEnumBody, TSEnumDeclaration, TSEnumMember, TSExportAssignment, TSExpressionWithTypeArguments, TSExternalModuleReference, TSFunctionType, TSImportEqualsDeclaration, TSImportType, TSIndexSignature, TSIndexedAccessType, TSInferType, TSInstantiationExpression, TSInterfaceBody, TSInterfaceDeclaration, TSIntersectionType, TSIntrinsicKeyword, TSLiteralType, TSMappedType, TSMethodSignature, TSModuleBlock, TSModuleDeclaration, TSNamedTupleMember, TSNamespaceExportDeclaration, TSNeverKeyword, TSNonNullExpression, TSNullKeyword, TSNumberKeyword, TSObjectKeyword, TSOptionalType, TSParameterProperty, TSParenthesizedType, TSPropertySignature, TSQualifiedName, TSRestType, TSSatisfiesExpression, TSStringKeyword, TSSymbolKeyword, TSTemplateLiteralType, TSThisType, TSTupleType, TSType, TSTypeAliasDeclaration, TSTypeAnnotation, TSTypeAssertion, TSTypeElement, TSTypeLiteral, TSTypeOperator, TSTypeParameter, TSTypeParameterDeclaration, TSTypeParameterInstantiation, TSTypePredicate, TSTypeQuery, TSTypeReference, TSUndefinedKeyword, TSUnionType, TSUnknownKeyword, TSVoidKeyword, TaggedTemplateExpression, TemplateElement, TemplateLiteral, Terminatorless, ThisExpression, ThisTypeAnnotation, ThrowStatement, TopicReference, TraversalAncestors, TraversalHandler, TraversalHandlers, TryStatement, TupleExpression, TupleTypeAnnotation, TypeAlias, TypeAnnotation, TypeCastExpression, TypeParameter, TypeParameterDeclaration, TypeParameterInstantiation, TypeScript, TypeofTypeAnnotation, UnaryExpression, UnaryLike, UnionTypeAnnotation, UpdateExpression, UserWhitespacable, V8IntrinsicIdentifier, VariableDeclaration, VariableDeclarator, Variance, VoidPattern, VoidTypeAnnotation, While, WhileStatement, WithStatement, YieldExpression, addComment, addComments, anyTypeAnnotation, appendToMemberExpression, argumentPlaceholder, arrayExpression, arrayPattern, arrayTypeAnnotation, arrowFunctionExpression, assertAccessor, assertAnyTypeAnnotation, assertArgumentPlaceholder, assertArrayExpression, assertArrayPattern, assertArrayTypeAnnotation, assertArrowFunctionExpression, assertAssignmentExpression, assertAssignmentPattern, assertAwaitExpression, assertBigIntLiteral, assertBinary, assertBinaryExpression, assertBindExpression, assertBlock, assertBlockParent, assertBlockStatement, assertBooleanLiteral, assertBooleanLiteralTypeAnnotation, assertBooleanTypeAnnotation, assertBreakStatement, assertCallExpression, assertCatchClause, assertClass, assertClassAccessorProperty, assertClassBody, assertClassDeclaration, assertClassExpression, assertClassImplements, assertClassMethod, assertClassPrivateMethod, assertClassPrivateProperty, assertClassProperty, assertCompletionStatement, assertConditional, assertConditionalExpression, assertContinueStatement, assertDebuggerStatement, assertDecimalLiteral, assertDeclaration, assertDeclareClass, assertDeclareExportAllDeclaration, assertDeclareExportDeclaration, assertDeclareFunction, assertDeclareInterface, assertDeclareModule, assertDeclareModuleExports, assertDeclareOpaqueType, assertDeclareTypeAlias, assertDeclareVariable, assertDeclaredPredicate, assertDecorator, assertDirective, assertDirectiveLiteral, assertDoExpression, assertDoWhileStatement, assertEmptyStatement, assertEmptyTypeAnnotation, assertEnumBody, assertEnumBooleanBody, assertEnumBooleanMember, assertEnumDeclaration, assertEnumDefaultedMember, assertEnumMember, assertEnumNumberBody, assertEnumNumberMember, assertEnumStringBody, assertEnumStringMember, assertEnumSymbolBody, assertExistsTypeAnnotation, assertExportAllDeclaration, assertExportDeclaration, assertExportDefaultDeclaration, assertExportDefaultSpecifier, assertExportNamedDeclaration, assertExportNamespaceSpecifier, assertExportSpecifier, assertExpression, assertExpressionStatement, assertExpressionWrapper, assertFile, assertFlow, assertFlowBaseAnnotation, assertFlowDeclaration, assertFlowPredicate, assertFlowType, assertFor, assertForInStatement, assertForOfStatement, assertForStatement, assertForXStatement, assertFunction, assertFunctionDeclaration, assertFunctionExpression, assertFunctionParameter, assertFunctionParent, assertFunctionTypeAnnotation, assertFunctionTypeParam, assertGenericTypeAnnotation, assertIdentifier, assertIfStatement, assertImmutable, assertImport, assertImportAttribute, assertImportDeclaration, assertImportDefaultSpecifier, assertImportExpression, assertImportNamespaceSpecifier, assertImportOrExportDeclaration, assertImportSpecifier, assertIndexedAccessType, assertInferredPredicate, assertInterfaceDeclaration, assertInterfaceExtends, assertInterfaceTypeAnnotation, assertInterpreterDirective, assertIntersectionTypeAnnotation, assertJSX, assertJSXAttribute, assertJSXClosingElement, assertJSXClosingFragment, assertJSXElement, assertJSXEmptyExpression, assertJSXExpressionContainer, assertJSXFragment, assertJSXIdentifier, assertJSXMemberExpression, assertJSXNamespacedName, assertJSXOpeningElement, assertJSXOpeningFragment, assertJSXSpreadAttribute, assertJSXSpreadChild, assertJSXText, assertLVal, assertLabeledStatement, assertLiteral, assertLogicalExpression, assertLoop, assertMemberExpression, assertMetaProperty, assertMethod, assertMiscellaneous, assertMixedTypeAnnotation, assertModuleDeclaration, assertModuleExpression, assertModuleSpecifier, assertNewExpression, assertNode, assertNoop, assertNullLiteral, assertNullLiteralTypeAnnotation, assertNullableTypeAnnotation, assertNumberLiteral, assertNumberLiteralTypeAnnotation, assertNumberTypeAnnotation, assertNumericLiteral, assertObjectExpression, assertObjectMember, assertObjectMethod, assertObjectPattern, assertObjectProperty, assertObjectTypeAnnotation, assertObjectTypeCallProperty, assertObjectTypeIndexer, assertObjectTypeInternalSlot, assertObjectTypeProperty, assertObjectTypeSpreadProperty, assertOpaqueType, assertOptionalCallExpression, assertOptionalIndexedAccessType, assertOptionalMemberExpression, assertParenthesizedExpression, assertPattern, assertPatternLike, assertPipelineBareFunction, assertPipelinePrimaryTopicReference, assertPipelineTopicExpression, assertPlaceholder, assertPrivate, assertPrivateName, assertProgram, assertProperty, assertPureish, assertQualifiedTypeIdentifier, assertRecordExpression, assertRegExpLiteral, assertRegexLiteral, assertRestElement, assertRestProperty, assertReturnStatement, assertScopable, assertSequenceExpression, assertSpreadElement, assertSpreadProperty, assertStandardized, assertStatement, assertStaticBlock, assertStringLiteral, assertStringLiteralTypeAnnotation, assertStringTypeAnnotation, assertSuper, assertSwitchCase, assertSwitchStatement, assertSymbolTypeAnnotation, assertTSAnyKeyword, assertTSArrayType, assertTSAsExpression, assertTSBaseType, assertTSBigIntKeyword, assertTSBooleanKeyword, assertTSCallSignatureDeclaration, assertTSConditionalType, assertTSConstructSignatureDeclaration, assertTSConstructorType, assertTSDeclareFunction, assertTSDeclareMethod, assertTSEntityName, assertTSEnumBody, assertTSEnumDeclaration, assertTSEnumMember, assertTSExportAssignment, assertTSExpressionWithTypeArguments, assertTSExternalModuleReference, assertTSFunctionType, assertTSImportEqualsDeclaration, assertTSImportType, assertTSIndexSignature, assertTSIndexedAccessType, assertTSInferType, assertTSInstantiationExpression, assertTSInterfaceBody, assertTSInterfaceDeclaration, assertTSIntersectionType, assertTSIntrinsicKeyword, assertTSLiteralType, assertTSMappedType, assertTSMethodSignature, assertTSModuleBlock, assertTSModuleDeclaration, assertTSNamedTupleMember, assertTSNamespaceExportDeclaration, assertTSNeverKeyword, assertTSNonNullExpression, assertTSNullKeyword, assertTSNumberKeyword, assertTSObjectKeyword, assertTSOptionalType, assertTSParameterProperty, assertTSParenthesizedType, assertTSPropertySignature, assertTSQualifiedName, assertTSRestType, assertTSSatisfiesExpression, assertTSStringKeyword, assertTSSymbolKeyword, assertTSTemplateLiteralType, assertTSThisType, assertTSTupleType, assertTSType, assertTSTypeAliasDeclaration, assertTSTypeAnnotation, assertTSTypeAssertion, assertTSTypeElement, assertTSTypeLiteral, assertTSTypeOperator, assertTSTypeParameter, assertTSTypeParameterDeclaration, assertTSTypeParameterInstantiation, assertTSTypePredicate, assertTSTypeQuery, assertTSTypeReference, assertTSUndefinedKeyword, assertTSUnionType, assertTSUnknownKeyword, assertTSVoidKeyword, assertTaggedTemplateExpression, assertTemplateElement, assertTemplateLiteral, assertTerminatorless, assertThisExpression, assertThisTypeAnnotation, assertThrowStatement, assertTopicReference, assertTryStatement, assertTupleExpression, assertTupleTypeAnnotation, assertTypeAlias, assertTypeAnnotation, assertTypeCastExpression, assertTypeParameter, assertTypeParameterDeclaration, assertTypeParameterInstantiation, assertTypeScript, assertTypeofTypeAnnotation, assertUnaryExpression, assertUnaryLike, assertUnionTypeAnnotation, assertUpdateExpression, assertUserWhitespacable, assertV8IntrinsicIdentifier, assertVariableDeclaration, assertVariableDeclarator, assertVariance, assertVoidPattern, assertVoidTypeAnnotation, assertWhile, assertWhileStatement, assertWithStatement, assertYieldExpression, assignmentExpression, assignmentPattern, awaitExpression, bigIntLiteral, binaryExpression, bindExpression, blockStatement, booleanLiteral, booleanLiteralTypeAnnotation, booleanTypeAnnotation, breakStatement, buildChildren, buildMatchMemberExpression, callExpression, catchClause, classAccessorProperty, classBody, classDeclaration, classExpression, classImplements, classMethod, classPrivateMethod, classPrivateProperty, classProperty, clone, cloneDeep, cloneDeepWithoutLoc, cloneNode, cloneWithoutLoc, conditionalExpression, continueStatement, createFlowUnionType, createTypeAnnotationBasedOnTypeof, createUnionTypeAnnotation, debuggerStatement, decimalLiteral, declareClass, declareExportAllDeclaration, declareExportDeclaration, declareFunction, declareInterface, declareModule, declareModuleExports, declareOpaqueType, declareTypeAlias, declareVariable, declaredPredicate, decorator, directive, directiveLiteral, doExpression, doWhileStatement, emptyStatement, emptyTypeAnnotation, ensureBlock, enumBooleanBody, enumBooleanMember, enumDeclaration, enumDefaultedMember, enumNumberBody, enumNumberMember, enumStringBody, enumStringMember, enumSymbolBody, existsTypeAnnotation, exportAllDeclaration, exportDefaultDeclaration, exportDefaultSpecifier, exportNamedDeclaration, exportNamespaceSpecifier, exportSpecifier, expressionStatement, file, forInStatement, forOfStatement, forStatement, functionDeclaration, functionExpression, functionTypeAnnotation, functionTypeParam, genericTypeAnnotation, getBindingIdentifiers, getOuterBindingIdentifiers, identifier, ifStatement, _import as import, importAttribute, importDeclaration, importDefaultSpecifier, importExpression, importNamespaceSpecifier, importSpecifier, indexedAccessType, inferredPredicate, inheritInnerComments, inheritLeadingComments, inheritTrailingComments, inherits, inheritsComments, interfaceDeclaration, interfaceExtends, interfaceTypeAnnotation, interpreterDirective, intersectionTypeAnnotation, is, isAccessor, isAnyTypeAnnotation, isArgumentPlaceholder, isArrayExpression, isArrayPattern, isArrayTypeAnnotation, isArrowFunctionExpression, isAssignmentExpression, isAssignmentPattern, isAwaitExpression, isBigIntLiteral, isBinary, isBinaryExpression, isBindExpression, isBinding, isBlock, isBlockParent, isBlockScoped, isBlockStatement, isBooleanLiteral, isBooleanLiteralTypeAnnotation, isBooleanTypeAnnotation, isBreakStatement, isCallExpression, isCatchClause, isClass, isClassAccessorProperty, isClassBody, isClassDeclaration, isClassExpression, isClassImplements, isClassMethod, isClassPrivateMethod, isClassPrivateProperty, isClassProperty, isCompletionStatement, isConditional, isConditionalExpression, isContinueStatement, isDebuggerStatement, isDecimalLiteral, isDeclaration, isDeclareClass, isDeclareExportAllDeclaration, isDeclareExportDeclaration, isDeclareFunction, isDeclareInterface, isDeclareModule, isDeclareModuleExports, isDeclareOpaqueType, isDeclareTypeAlias, isDeclareVariable, isDeclaredPredicate, isDecorator, isDirective, isDirectiveLiteral, isDoExpression, isDoWhileStatement, isEmptyStatement, isEmptyTypeAnnotation, isEnumBody, isEnumBooleanBody, isEnumBooleanMember, isEnumDeclaration, isEnumDefaultedMember, isEnumMember, isEnumNumberBody, isEnumNumberMember, isEnumStringBody, isEnumStringMember, isEnumSymbolBody, isExistsTypeAnnotation, isExportAllDeclaration, isExportDeclaration, isExportDefaultDeclaration, isExportDefaultSpecifier, isExportNamedDeclaration, isExportNamespaceSpecifier, isExportSpecifier, isExpression, isExpressionStatement, isExpressionWrapper, isFile, isFlow, isFlowBaseAnnotation, isFlowDeclaration, isFlowPredicate, isFlowType, isFor, isForInStatement, isForOfStatement, isForStatement, isForXStatement, isFunction, isFunctionDeclaration, isFunctionExpression, isFunctionParameter, isFunctionParent, isFunctionTypeAnnotation, isFunctionTypeParam, isGenericTypeAnnotation, isIdentifier, isIfStatement, isImmutable, isImport, isImportAttribute, isImportDeclaration, isImportDefaultSpecifier, isImportExpression, isImportNamespaceSpecifier, isImportOrExportDeclaration, isImportSpecifier, isIndexedAccessType, isInferredPredicate, isInterfaceDeclaration, isInterfaceExtends, isInterfaceTypeAnnotation, isInterpreterDirective, isIntersectionTypeAnnotation, isJSX, isJSXAttribute, isJSXClosingElement, isJSXClosingFragment, isJSXElement, isJSXEmptyExpression, isJSXExpressionContainer, isJSXFragment, isJSXIdentifier, isJSXMemberExpression, isJSXNamespacedName, isJSXOpeningElement, isJSXOpeningFragment, isJSXSpreadAttribute, isJSXSpreadChild, isJSXText, isLVal, isLabeledStatement, isLet, isLiteral, isLogicalExpression, isLoop, isMemberExpression, isMetaProperty, isMethod, isMiscellaneous, isMixedTypeAnnotation, isModuleDeclaration, isModuleExpression, isModuleSpecifier, isNewExpression, isNode, isNodesEquivalent, isNoop, isNullLiteral, isNullLiteralTypeAnnotation, isNullableTypeAnnotation, isNumberLiteral, isNumberLiteralTypeAnnotation, isNumberTypeAnnotation, isNumericLiteral, isObjectExpression, isObjectMember, isObjectMethod, isObjectPattern, isObjectProperty, isObjectTypeAnnotation, isObjectTypeCallProperty, isObjectTypeIndexer, isObjectTypeInternalSlot, isObjectTypeProperty, isObjectTypeSpreadProperty, isOpaqueType, isOptionalCallExpression, isOptionalIndexedAccessType, isOptionalMemberExpression, isParenthesizedExpression, isPattern, isPatternLike, isPipelineBareFunction, isPipelinePrimaryTopicReference, isPipelineTopicExpression, isPlaceholder, isPlaceholderType, isPrivate, isPrivateName, isProgram, isProperty, isPureish, isQualifiedTypeIdentifier, isRecordExpression, isReferenced, isRegExpLiteral, isRegexLiteral, isRestElement, isRestProperty, isReturnStatement, isScopable, isScope, isSequenceExpression, isSpecifierDefault, isSpreadElement, isSpreadProperty, isStandardized, isStatement, isStaticBlock, isStringLiteral, isStringLiteralTypeAnnotation, isStringTypeAnnotation, isSuper, isSwitchCase, isSwitchStatement, isSymbolTypeAnnotation, isTSAnyKeyword, isTSArrayType, isTSAsExpression, isTSBaseType, isTSBigIntKeyword, isTSBooleanKeyword, isTSCallSignatureDeclaration, isTSConditionalType, isTSConstructSignatureDeclaration, isTSConstructorType, isTSDeclareFunction, isTSDeclareMethod, isTSEntityName, isTSEnumBody, isTSEnumDeclaration, isTSEnumMember, isTSExportAssignment, isTSExpressionWithTypeArguments, isTSExternalModuleReference, isTSFunctionType, isTSImportEqualsDeclaration, isTSImportType, isTSIndexSignature, isTSIndexedAccessType, isTSInferType, isTSInstantiationExpression, isTSInterfaceBody, isTSInterfaceDeclaration, isTSIntersectionType, isTSIntrinsicKeyword, isTSLiteralType, isTSMappedType, isTSMethodSignature, isTSModuleBlock, isTSModuleDeclaration, isTSNamedTupleMember, isTSNamespaceExportDeclaration, isTSNeverKeyword, isTSNonNullExpression, isTSNullKeyword, isTSNumberKeyword, isTSObjectKeyword, isTSOptionalType, isTSParameterProperty, isTSParenthesizedType, isTSPropertySignature, isTSQualifiedName, isTSRestType, isTSSatisfiesExpression, isTSStringKeyword, isTSSymbolKeyword, isTSTemplateLiteralType, isTSThisType, isTSTupleType, isTSType, isTSTypeAliasDeclaration, isTSTypeAnnotation, isTSTypeAssertion, isTSTypeElement, isTSTypeLiteral, isTSTypeOperator, isTSTypeParameter, isTSTypeParameterDeclaration, isTSTypeParameterInstantiation, isTSTypePredicate, isTSTypeQuery, isTSTypeReference, isTSUndefinedKeyword, isTSUnionType, isTSUnknownKeyword, isTSVoidKeyword, isTaggedTemplateExpression, isTemplateElement, isTemplateLiteral, isTerminatorless, isThisExpression, isThisTypeAnnotation, isThrowStatement, isTopicReference, isTryStatement, isTupleExpression, isTupleTypeAnnotation, isType, isTypeAlias, isTypeAnnotation, isTypeCastExpression, isTypeParameter, isTypeParameterDeclaration, isTypeParameterInstantiation, isTypeScript, isTypeofTypeAnnotation, isUnaryExpression, isUnaryLike, isUnionTypeAnnotation, isUpdateExpression, isUserWhitespacable, isV8IntrinsicIdentifier, isValidES3Identifier, isValidIdentifier, isVar, isVariableDeclaration, isVariableDeclarator, isVariance, isVoidPattern, isVoidTypeAnnotation, isWhile, isWhileStatement, isWithStatement, isYieldExpression, jsxAttribute, jsxClosingElement, jsxClosingFragment, jsxElement, jsxEmptyExpression, jsxExpressionContainer, jsxFragment, jsxIdentifier, jsxMemberExpression, jsxNamespacedName, jsxOpeningElement, jsxOpeningFragment, jsxSpreadAttribute, jsxSpreadChild, jsxText, labeledStatement, logicalExpression, matchesPattern, memberExpression, metaProperty, mixedTypeAnnotation, moduleExpression, newExpression, noop, nullLiteral, nullLiteralTypeAnnotation, nullableTypeAnnotation, numberLiteralTypeAnnotation, numberTypeAnnotation, numericLiteral, objectExpression, objectMethod, objectPattern, objectProperty, objectTypeAnnotation, objectTypeCallProperty, objectTypeIndexer, objectTypeInternalSlot, objectTypeProperty, objectTypeSpreadProperty, opaqueType, optionalCallExpression, optionalIndexedAccessType, optionalMemberExpression, parenthesizedExpression, pipelineBareFunction, pipelinePrimaryTopicReference, pipelineTopicExpression, placeholder, prependToMemberExpression, privateName, program, qualifiedTypeIdentifier, recordExpression, regExpLiteral, removeComments, removeProperties, removePropertiesDeep, removeTypeDuplicates, restElement, returnStatement, sequenceExpression, shallowEqual, spreadElement, staticBlock, stringLiteral, stringLiteralTypeAnnotation, stringTypeAnnotation, _super as super, switchCase, switchStatement, symbolTypeAnnotation, taggedTemplateExpression, templateElement, templateLiteral, thisExpression, thisTypeAnnotation, throwStatement, toBindingIdentifierName, toBlock, toComputedKey, toExpression, toIdentifier, toKeyAlias, toSequenceExpression, toStatement, topicReference, traverse, traverseFast, tryStatement, tsAnyKeyword, tsArrayType, tsAsExpression, tsBigIntKeyword, tsBooleanKeyword, tsCallSignatureDeclaration, tsConditionalType, tsConstructSignatureDeclaration, tsConstructorType, tsDeclareFunction, tsDeclareMethod, tsEnumBody, tsEnumDeclaration, tsEnumMember, tsExportAssignment, tsExpressionWithTypeArguments, tsExternalModuleReference, tsFunctionType, tsImportEqualsDeclaration, tsImportType, tsIndexSignature, tsIndexedAccessType, tsInferType, tsInstantiationExpression, tsInterfaceBody, tsInterfaceDeclaration, tsIntersectionType, tsIntrinsicKeyword, tsLiteralType, tsMappedType, tsMethodSignature, tsModuleBlock, tsModuleDeclaration, tsNamedTupleMember, tsNamespaceExportDeclaration, tsNeverKeyword, tsNonNullExpression, tsNullKeyword, tsNumberKeyword, tsObjectKeyword, tsOptionalType, tsParameterProperty, tsParenthesizedType, tsPropertySignature, tsQualifiedName, tsRestType, tsSatisfiesExpression, tsStringKeyword, tsSymbolKeyword, tsTemplateLiteralType, tsThisType, tsTupleType, tsTypeAliasDeclaration, tsTypeAnnotation, tsTypeAssertion, tsTypeLiteral, tsTypeOperator, tsTypeParameter, tsTypeParameterDeclaration, tsTypeParameterInstantiation, tsTypePredicate, tsTypeQuery, tsTypeReference, tsUndefinedKeyword, tsUnionType, tsUnknownKeyword, tsVoidKeyword, tupleExpression, tupleTypeAnnotation, typeAlias, typeAnnotation, typeCastExpression, typeParameter, typeParameterDeclaration, typeParameterInstantiation, typeofTypeAnnotation, unaryExpression, unionTypeAnnotation, updateExpression, v8IntrinsicIdentifier, validate, valueToNode, variableDeclaration, variableDeclarator, variance, voidPattern, voidTypeAnnotation, whileStatement, withStatement, yieldExpression };
+}
+// NOTE: This file is autogenerated. Do not modify.
+// See packages/babel-types/scripts/generators/typescript-legacy.ts for script used.
+interface BaseComment {
+  value: string;
+  start: number;
+  end: number;
+  loc: SourceLocation;
+  type: "CommentBlock" | "CommentLine";
+}
+interface CommentBlock extends BaseComment {
+  type: "CommentBlock";
+}
+interface CommentLine extends BaseComment {
+  type: "CommentLine";
+}
+type Comment = CommentBlock | CommentLine;
+interface SourceLocation {
+  start: {
+    line: number;
+    column: number;
+  };
+  end: {
+    line: number;
+    column: number;
+  };
+}
+interface BaseNode {
+  leadingComments: ReadonlyArray<Comment> | null;
+  innerComments: ReadonlyArray<Comment> | null;
+  trailingComments: ReadonlyArray<Comment> | null;
+  start: number | null;
+  end: number | null;
+  loc: SourceLocation | null;
+  type: Node["type"];
+  extra?: Record<string, unknown>;
+}
+type Node = Accessor | AnyTypeAnnotation | ArgumentPlaceholder | ArrayExpression | ArrayPattern | ArrayTypeAnnotation | ArrowFunctionExpression | AssignmentExpression | AssignmentPattern | AwaitExpression | BigIntLiteral | Binary | BinaryExpression | BindExpression | Block | BlockParent | BlockStatement | BooleanLiteral | BooleanLiteralTypeAnnotation | BooleanTypeAnnotation | BreakStatement | CallExpression | CatchClause | Class | ClassAccessorProperty | ClassBody | ClassDeclaration | ClassExpression | ClassImplements | ClassMethod | ClassPrivateMethod | ClassPrivateProperty | ClassProperty | CompletionStatement | Conditional | ConditionalExpression | ContinueStatement | DebuggerStatement | DecimalLiteral | Declaration | DeclareClass | DeclareExportAllDeclaration | DeclareExportDeclaration | DeclareFunction | DeclareInterface | DeclareModule | DeclareModuleExports | DeclareOpaqueType | DeclareTypeAlias | DeclareVariable | DeclaredPredicate | Decorator | Directive | DirectiveLiteral | DoExpression | DoWhileStatement | EmptyStatement | EmptyTypeAnnotation | EnumBody | EnumBooleanBody | EnumBooleanMember | EnumDeclaration | EnumDefaultedMember | EnumMember | EnumNumberBody | EnumNumberMember | EnumStringBody | EnumStringMember | EnumSymbolBody | ExistsTypeAnnotation | ExportAllDeclaration | ExportDeclaration | ExportDefaultDeclaration | ExportDefaultSpecifier | ExportNamedDeclaration | ExportNamespaceSpecifier | ExportSpecifier | Expression | ExpressionStatement | ExpressionWrapper | File | Flow | FlowBaseAnnotation | FlowDeclaration | FlowPredicate | FlowType | For | ForInStatement | ForOfStatement | ForStatement | ForXStatement | Function | FunctionDeclaration | FunctionExpression | FunctionParameter | FunctionParent | FunctionTypeAnnotation | FunctionTypeParam | GenericTypeAnnotation | Identifier | IfStatement | Immutable | Import | ImportAttribute | ImportDeclaration | ImportDefaultSpecifier | ImportExpression | ImportNamespaceSpecifier | ImportOrExportDeclaration | ImportSpecifier | IndexedAccessType | InferredPredicate | InterfaceDeclaration | InterfaceExtends | InterfaceTypeAnnotation | InterpreterDirective | IntersectionTypeAnnotation | JSX | JSXAttribute | JSXClosingElement | JSXClosingFragment | JSXElement | JSXEmptyExpression | JSXExpressionContainer | JSXFragment | JSXIdentifier | JSXMemberExpression | JSXNamespacedName | JSXOpeningElement | JSXOpeningFragment | JSXSpreadAttribute | JSXSpreadChild | JSXText | LVal | LabeledStatement | Literal | LogicalExpression | Loop | MemberExpression | MetaProperty | Method | Miscellaneous | MixedTypeAnnotation | ModuleDeclaration | ModuleExpression | ModuleSpecifier | NewExpression | Noop | NullLiteral | NullLiteralTypeAnnotation | NullableTypeAnnotation | NumberLiteral | NumberLiteralTypeAnnotation | NumberTypeAnnotation | NumericLiteral | ObjectExpression | ObjectMember | ObjectMethod | ObjectPattern | ObjectProperty | ObjectTypeAnnotation | ObjectTypeCallProperty | ObjectTypeIndexer | ObjectTypeInternalSlot | ObjectTypeProperty | ObjectTypeSpreadProperty | OpaqueType | OptionalCallExpression | OptionalIndexedAccessType | OptionalMemberExpression | ParenthesizedExpression | Pattern | PatternLike | PipelineBareFunction | PipelinePrimaryTopicReference | PipelineTopicExpression | Placeholder | Private | PrivateName | Program | Property | Pureish | QualifiedTypeIdentifier | RecordExpression | RegExpLiteral | RegexLiteral | RestElement | RestProperty | ReturnStatement | Scopable | SequenceExpression | SpreadElement | SpreadProperty | Standardized | Statement | StaticBlock | StringLiteral | StringLiteralTypeAnnotation | StringTypeAnnotation | Super | SwitchCase | SwitchStatement | SymbolTypeAnnotation | TSAnyKeyword | TSArrayType | TSAsExpression | TSBaseType | TSBigIntKeyword | TSBooleanKeyword | TSCallSignatureDeclaration | TSConditionalType | TSConstructSignatureDeclaration | TSConstructorType | TSDeclareFunction | TSDeclareMethod | TSEntityName | TSEnumBody | TSEnumDeclaration | TSEnumMember | TSExportAssignment | TSExpressionWithTypeArguments | TSExternalModuleReference | TSFunctionType | TSImportEqualsDeclaration | TSImportType | TSIndexSignature | TSIndexedAccessType | TSInferType | TSInstantiationExpression | TSInterfaceBody | TSInterfaceDeclaration | TSIntersectionType | TSIntrinsicKeyword | TSLiteralType | TSMappedType | TSMethodSignature | TSModuleBlock | TSModuleDeclaration | TSNamedTupleMember | TSNamespaceExportDeclaration | TSNeverKeyword | TSNonNullExpression | TSNullKeyword | TSNumberKeyword | TSObjectKeyword | TSOptionalType | TSParameterProperty | TSParenthesizedType | TSPropertySignature | TSQualifiedName | TSRestType | TSSatisfiesExpression | TSStringKeyword | TSSymbolKeyword | TSTemplateLiteralType | TSThisType | TSTupleType | TSType | TSTypeAliasDeclaration | TSTypeAnnotation | TSTypeAssertion | TSTypeElement | TSTypeLiteral | TSTypeOperator | TSTypeParameter | TSTypeParameterDeclaration | TSTypeParameterInstantiation | TSTypePredicate | TSTypeQuery | TSTypeReference | TSUndefinedKeyword | TSUnionType | TSUnknownKeyword | TSVoidKeyword | TaggedTemplateExpression | TemplateElement | TemplateLiteral | Terminatorless | ThisExpression | ThisTypeAnnotation | ThrowStatement | TopicReference | TryStatement | TupleExpression | TupleTypeAnnotation | TypeAlias | TypeAnnotation | TypeCastExpression | TypeParameter | TypeParameterDeclaration | TypeParameterInstantiation | TypeScript | TypeofTypeAnnotation | UnaryExpression | UnaryLike | UnionTypeAnnotation | UpdateExpression | UserWhitespacable | V8IntrinsicIdentifier | VariableDeclaration | VariableDeclarator | Variance | VoidPattern | VoidTypeAnnotation | While | WhileStatement | WithStatement | YieldExpression;
+interface ArrayExpression extends BaseNode {
+  type: "ArrayExpression";
+  elements: (null | Expression | SpreadElement)[];
+}
+interface AssignmentExpression extends BaseNode {
+  type: "AssignmentExpression";
+  operator: string;
+  left: LVal | OptionalMemberExpression;
+  right: Expression;
+}
+interface BinaryExpression extends BaseNode {
+  type: "BinaryExpression";
+  operator: "+" | "-" | "/" | "%" | "*" | "**" | "&" | "|" | ">>" | ">>>" | "<<" | "^" | "==" | "===" | "!=" | "!==" | "in" | "instanceof" | ">" | "<" | ">=" | "<=" | "|>";
+  left: Expression | PrivateName;
+  right: Expression;
+}
+interface InterpreterDirective extends BaseNode {
+  type: "InterpreterDirective";
+  value: string;
+}
+interface Directive extends BaseNode {
+  type: "Directive";
+  value: DirectiveLiteral;
+}
+interface DirectiveLiteral extends BaseNode {
+  type: "DirectiveLiteral";
+  value: string;
+}
+interface BlockStatement extends BaseNode {
+  type: "BlockStatement";
+  body: Statement[];
+  directives: Directive[];
+}
+interface BreakStatement extends BaseNode {
+  type: "BreakStatement";
+  label: Identifier | null;
+}
+interface CallExpression extends BaseNode {
+  type: "CallExpression";
+  callee: Expression | Super | V8IntrinsicIdentifier;
+  arguments: (Expression | SpreadElement | ArgumentPlaceholder)[];
+  optional: boolean | null;
+  typeArguments: TypeParameterInstantiation | null;
+  typeParameters: TSTypeParameterInstantiation | null;
+}
+interface CatchClause extends BaseNode {
+  type: "CatchClause";
+  param: Identifier | ArrayPattern | ObjectPattern | null;
+  body: BlockStatement;
+}
+interface ConditionalExpression extends BaseNode {
+  type: "ConditionalExpression";
+  test: Expression;
+  consequent: Expression;
+  alternate: Expression;
+}
+interface ContinueStatement extends BaseNode {
+  type: "ContinueStatement";
+  label: Identifier | null;
+}
+interface DebuggerStatement extends BaseNode {
+  type: "DebuggerStatement";
+}
+interface DoWhileStatement extends BaseNode {
+  type: "DoWhileStatement";
+  test: Expression;
+  body: Statement;
+}
+interface EmptyStatement extends BaseNode {
+  type: "EmptyStatement";
+}
+interface ExpressionStatement extends BaseNode {
+  type: "ExpressionStatement";
+  expression: Expression;
+}
+interface File extends BaseNode {
+  type: "File";
+  program: Program;
+  comments: (CommentBlock | CommentLine)[] | null;
+  tokens: any[] | null;
+}
+interface ForInStatement extends BaseNode {
+  type: "ForInStatement";
+  left: VariableDeclaration | LVal;
+  right: Expression;
+  body: Statement;
+}
+interface ForStatement extends BaseNode {
+  type: "ForStatement";
+  init: VariableDeclaration | Expression | null;
+  test: Expression | null;
+  update: Expression | null;
+  body: Statement;
+}
+interface FunctionDeclaration extends BaseNode {
+  type: "FunctionDeclaration";
+  id: Identifier | null;
+  params: FunctionParameter[];
+  body: BlockStatement;
+  generator: boolean;
+  async: boolean;
+  declare: boolean | null;
+  predicate: DeclaredPredicate | InferredPredicate | null;
+  returnType: TypeAnnotation | TSTypeAnnotation | Noop | null;
+  typeParameters: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop | null;
+}
+interface FunctionExpression extends BaseNode {
+  type: "FunctionExpression";
+  id: Identifier | null;
+  params: FunctionParameter[];
+  body: BlockStatement;
+  generator: boolean;
+  async: boolean;
+  predicate: DeclaredPredicate | InferredPredicate | null;
+  returnType: TypeAnnotation | TSTypeAnnotation | Noop | null;
+  typeParameters: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop | null;
+}
+interface Identifier extends BaseNode {
+  type: "Identifier";
+  name: string;
+  decorators: Decorator[] | null;
+  optional: boolean | null;
+  typeAnnotation: TypeAnnotation | TSTypeAnnotation | Noop | null;
+}
+interface IfStatement extends BaseNode {
+  type: "IfStatement";
+  test: Expression;
+  consequent: Statement;
+  alternate: Statement | null;
+}
+interface LabeledStatement extends BaseNode {
+  type: "LabeledStatement";
+  label: Identifier;
+  body: Statement;
+}
+interface StringLiteral extends BaseNode {
+  type: "StringLiteral";
+  value: string;
+}
+interface NumericLiteral extends BaseNode {
+  type: "NumericLiteral";
+  value: number;
+}
+interface NullLiteral extends BaseNode {
+  type: "NullLiteral";
+}
+interface BooleanLiteral extends BaseNode {
+  type: "BooleanLiteral";
+  value: boolean;
+}
+interface RegExpLiteral extends BaseNode {
+  type: "RegExpLiteral";
+  pattern: string;
+  flags: string;
+}
+interface LogicalExpression extends BaseNode {
+  type: "LogicalExpression";
+  operator: "||" | "&&" | "??";
+  left: Expression;
+  right: Expression;
+}
+interface MemberExpression extends BaseNode {
+  type: "MemberExpression";
+  object: Expression | Super;
+  property: Expression | Identifier | PrivateName;
+  computed: boolean;
+  optional: boolean | null;
+}
+interface NewExpression extends BaseNode {
+  type: "NewExpression";
+  callee: Expression | Super | V8IntrinsicIdentifier;
+  arguments: (Expression | SpreadElement | ArgumentPlaceholder)[];
+  optional: boolean | null;
+  typeArguments: TypeParameterInstantiation | null;
+  typeParameters: TSTypeParameterInstantiation | null;
+}
+interface Program extends BaseNode {
+  type: "Program";
+  body: Statement[];
+  directives: Directive[];
+  sourceType: "script" | "module";
+  interpreter: InterpreterDirective | null;
+}
+interface ObjectExpression extends BaseNode {
+  type: "ObjectExpression";
+  properties: (ObjectMethod | ObjectProperty | SpreadElement)[];
+}
+interface ObjectMethod extends BaseNode {
+  type: "ObjectMethod";
+  kind: "method" | "get" | "set";
+  key: Expression | Identifier | StringLiteral | NumericLiteral | BigIntLiteral;
+  params: FunctionParameter[];
+  body: BlockStatement;
+  computed: boolean;
+  generator: boolean;
+  async: boolean;
+  decorators: Decorator[] | null;
+  returnType: TypeAnnotation | TSTypeAnnotation | Noop | null;
+  typeParameters: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop | null;
+}
+interface ObjectProperty extends BaseNode {
+  type: "ObjectProperty";
+  key: Expression | Identifier | StringLiteral | NumericLiteral | BigIntLiteral | DecimalLiteral | PrivateName;
+  value: Expression | PatternLike;
+  computed: boolean;
+  shorthand: boolean;
+  decorators: Decorator[] | null;
+}
+interface RestElement extends BaseNode {
+  type: "RestElement";
+  argument: Identifier | ArrayPattern | ObjectPattern | MemberExpression | TSAsExpression | TSSatisfiesExpression | TSTypeAssertion | TSNonNullExpression | RestElement | AssignmentPattern;
+  decorators: Decorator[] | null;
+  optional: boolean | null;
+  typeAnnotation: TypeAnnotation | TSTypeAnnotation | Noop | null;
+}
+interface ReturnStatement extends BaseNode {
+  type: "ReturnStatement";
+  argument: Expression | null;
+}
+interface SequenceExpression extends BaseNode {
+  type: "SequenceExpression";
+  expressions: Expression[];
+}
+interface ParenthesizedExpression extends BaseNode {
+  type: "ParenthesizedExpression";
+  expression: Expression;
+}
+interface SwitchCase extends BaseNode {
+  type: "SwitchCase";
+  test: Expression | null;
+  consequent: Statement[];
+}
+interface SwitchStatement extends BaseNode {
+  type: "SwitchStatement";
+  discriminant: Expression;
+  cases: SwitchCase[];
+}
+interface ThisExpression extends BaseNode {
+  type: "ThisExpression";
+}
+interface ThrowStatement extends BaseNode {
+  type: "ThrowStatement";
+  argument: Expression;
+}
+interface TryStatement extends BaseNode {
+  type: "TryStatement";
+  block: BlockStatement;
+  handler: CatchClause | null;
+  finalizer: BlockStatement | null;
+}
+interface UnaryExpression extends BaseNode {
+  type: "UnaryExpression";
+  operator: "void" | "throw" | "delete" | "!" | "+" | "-" | "~" | "typeof";
+  argument: Expression;
+  prefix: boolean;
+}
+interface UpdateExpression extends BaseNode {
+  type: "UpdateExpression";
+  operator: "++" | "--";
+  argument: Expression;
+  prefix: boolean;
+}
+interface VariableDeclaration extends BaseNode {
+  type: "VariableDeclaration";
+  kind: "var" | "let" | "const" | "using" | "await using";
+  declarations: VariableDeclarator[];
+  declare: boolean | null;
+}
+interface VariableDeclarator extends BaseNode {
+  type: "VariableDeclarator";
+  id: LVal | VoidPattern;
+  init: Expression | null;
+  definite: boolean | null;
+}
+interface WhileStatement extends BaseNode {
+  type: "WhileStatement";
+  test: Expression;
+  body: Statement;
+}
+interface WithStatement extends BaseNode {
+  type: "WithStatement";
+  object: Expression;
+  body: Statement;
+}
+interface AssignmentPattern extends BaseNode {
+  type: "AssignmentPattern";
+  left: Identifier | ObjectPattern | ArrayPattern | MemberExpression | TSAsExpression | TSSatisfiesExpression | TSTypeAssertion | TSNonNullExpression;
+  right: Expression;
+  decorators: Decorator[] | null;
+  optional: boolean | null;
+  typeAnnotation: TypeAnnotation | TSTypeAnnotation | Noop | null;
+}
+interface ArrayPattern extends BaseNode {
+  type: "ArrayPattern";
+  elements: (null | PatternLike)[];
+  decorators: Decorator[] | null;
+  optional: boolean | null;
+  typeAnnotation: TypeAnnotation | TSTypeAnnotation | Noop | null;
+}
+interface ArrowFunctionExpression extends BaseNode {
+  type: "ArrowFunctionExpression";
+  params: FunctionParameter[];
+  body: BlockStatement | Expression;
+  async: boolean;
+  expression: boolean;
+  generator: boolean;
+  predicate: DeclaredPredicate | InferredPredicate | null;
+  returnType: TypeAnnotation | TSTypeAnnotation | Noop | null;
+  typeParameters: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop | null;
+}
+interface ClassBody extends BaseNode {
+  type: "ClassBody";
+  body: (ClassMethod | ClassPrivateMethod | ClassProperty | ClassPrivateProperty | ClassAccessorProperty | TSDeclareMethod | TSIndexSignature | StaticBlock)[];
+}
+interface ClassExpression extends BaseNode {
+  type: "ClassExpression";
+  id: Identifier | null;
+  superClass: Expression | null;
+  body: ClassBody;
+  decorators: Decorator[] | null;
+  implements: (TSExpressionWithTypeArguments | ClassImplements)[] | null;
+  mixins: InterfaceExtends | null;
+  superTypeParameters: TypeParameterInstantiation | TSTypeParameterInstantiation | null;
+  typeParameters: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop | null;
+}
+interface ClassDeclaration extends BaseNode {
+  type: "ClassDeclaration";
+  id: Identifier | null;
+  superClass: Expression | null;
+  body: ClassBody;
+  decorators: Decorator[] | null;
+  abstract: boolean | null;
+  declare: boolean | null;
+  implements: (TSExpressionWithTypeArguments | ClassImplements)[] | null;
+  mixins: InterfaceExtends | null;
+  superTypeParameters: TypeParameterInstantiation | TSTypeParameterInstantiation | null;
+  typeParameters: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop | null;
+}
+interface ExportAllDeclaration extends BaseNode {
+  type: "ExportAllDeclaration";
+  source: StringLiteral;
+  attributes: ImportAttribute[] | null;
+  assertions: ImportAttribute[] | null;
+  exportKind: "type" | "value" | null;
+}
+interface ExportDefaultDeclaration extends BaseNode {
+  type: "ExportDefaultDeclaration";
+  declaration: TSDeclareFunction | FunctionDeclaration | ClassDeclaration | Expression;
+  exportKind: "value" | null;
+}
+interface ExportNamedDeclaration extends BaseNode {
+  type: "ExportNamedDeclaration";
+  declaration: Declaration | null;
+  specifiers: (ExportSpecifier | ExportDefaultSpecifier | ExportNamespaceSpecifier)[];
+  source: StringLiteral | null;
+  attributes: ImportAttribute[] | null;
+  assertions: ImportAttribute[] | null;
+  exportKind: "type" | "value" | null;
+}
+interface ExportSpecifier extends BaseNode {
+  type: "ExportSpecifier";
+  local: Identifier;
+  exported: Identifier | StringLiteral;
+  exportKind: "type" | "value" | null;
+}
+interface ForOfStatement extends BaseNode {
+  type: "ForOfStatement";
+  left: VariableDeclaration | LVal;
+  right: Expression;
+  body: Statement;
+  await: boolean;
+}
+interface ImportDeclaration extends BaseNode {
+  type: "ImportDeclaration";
+  specifiers: (ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier)[];
+  source: StringLiteral;
+  attributes: ImportAttribute[] | null;
+  assertions: ImportAttribute[] | null;
+  importKind: "type" | "typeof" | "value" | null;
+  module: boolean | null;
+  phase: "source" | "defer" | null;
+}
+interface ImportDefaultSpecifier extends BaseNode {
+  type: "ImportDefaultSpecifier";
+  local: Identifier;
+}
+interface ImportNamespaceSpecifier extends BaseNode {
+  type: "ImportNamespaceSpecifier";
+  local: Identifier;
+}
+interface ImportSpecifier extends BaseNode {
+  type: "ImportSpecifier";
+  local: Identifier;
+  imported: Identifier | StringLiteral;
+  importKind: "type" | "typeof" | "value" | null;
+}
+interface ImportExpression extends BaseNode {
+  type: "ImportExpression";
+  source: Expression;
+  options: Expression | null;
+  phase: "source" | "defer" | null;
+}
+interface MetaProperty extends BaseNode {
+  type: "MetaProperty";
+  meta: Identifier;
+  property: Identifier;
+}
+interface ClassMethod extends BaseNode {
+  type: "ClassMethod";
+  kind: "get" | "set" | "method" | "constructor";
+  key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | Expression;
+  params: (FunctionParameter | TSParameterProperty)[];
+  body: BlockStatement;
+  computed: boolean;
+  static: boolean;
+  generator: boolean;
+  async: boolean;
+  abstract: boolean | null;
+  access: "public" | "private" | "protected" | null;
+  accessibility: "public" | "private" | "protected" | null;
+  decorators: Decorator[] | null;
+  optional: boolean | null;
+  override: boolean;
+  returnType: TypeAnnotation | TSTypeAnnotation | Noop | null;
+  typeParameters: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop | null;
+}
+interface ObjectPattern extends BaseNode {
+  type: "ObjectPattern";
+  properties: (RestElement | ObjectProperty)[];
+  decorators: Decorator[] | null;
+  optional: boolean | null;
+  typeAnnotation: TypeAnnotation | TSTypeAnnotation | Noop | null;
+}
+interface SpreadElement extends BaseNode {
+  type: "SpreadElement";
+  argument: Expression;
+}
+interface Super extends BaseNode {
+  type: "Super";
+}
+interface TaggedTemplateExpression extends BaseNode {
+  type: "TaggedTemplateExpression";
+  tag: Expression;
+  quasi: TemplateLiteral;
+  typeParameters: TypeParameterInstantiation | TSTypeParameterInstantiation | null;
+}
+interface TemplateElement extends BaseNode {
+  type: "TemplateElement";
+  value: {
+    raw: string;
+    cooked?: string;
+  };
+  tail: boolean;
+}
+interface TemplateLiteral extends BaseNode {
+  type: "TemplateLiteral";
+  quasis: TemplateElement[];
+  expressions: (Expression | TSType)[];
+}
+interface YieldExpression extends BaseNode {
+  type: "YieldExpression";
+  argument: Expression | null;
+  delegate: boolean;
+}
+interface AwaitExpression extends BaseNode {
+  type: "AwaitExpression";
+  argument: Expression;
+}
+interface Import extends BaseNode {
+  type: "Import";
+}
+interface BigIntLiteral extends BaseNode {
+  type: "BigIntLiteral";
+  value: string;
+}
+interface ExportNamespaceSpecifier extends BaseNode {
+  type: "ExportNamespaceSpecifier";
+  exported: Identifier;
+}
+interface OptionalMemberExpression extends BaseNode {
+  type: "OptionalMemberExpression";
+  object: Expression;
+  property: Expression | Identifier;
+  computed: boolean;
+  optional: boolean;
+}
+interface OptionalCallExpression extends BaseNode {
+  type: "OptionalCallExpression";
+  callee: Expression;
+  arguments: (Expression | SpreadElement | ArgumentPlaceholder)[];
+  optional: boolean;
+  typeArguments: TypeParameterInstantiation | null;
+  typeParameters: TSTypeParameterInstantiation | null;
+}
+interface ClassProperty extends BaseNode {
+  type: "ClassProperty";
+  key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | Expression;
+  value: Expression | null;
+  typeAnnotation: TypeAnnotation | TSTypeAnnotation | Noop | null;
+  decorators: Decorator[] | null;
+  computed: boolean;
+  static: boolean;
+  abstract: boolean | null;
+  accessibility: "public" | "private" | "protected" | null;
+  declare: boolean | null;
+  definite: boolean | null;
+  optional: boolean | null;
+  override: boolean;
+  readonly: boolean | null;
+  variance: Variance | null;
+}
+interface ClassAccessorProperty extends BaseNode {
+  type: "ClassAccessorProperty";
+  key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | Expression | PrivateName;
+  value: Expression | null;
+  typeAnnotation: TypeAnnotation | TSTypeAnnotation | Noop | null;
+  decorators: Decorator[] | null;
+  computed: boolean;
+  static: boolean;
+  abstract: boolean | null;
+  accessibility: "public" | "private" | "protected" | null;
+  declare: boolean | null;
+  definite: boolean | null;
+  optional: boolean | null;
+  override: boolean;
+  readonly: boolean | null;
+  variance: Variance | null;
+}
+interface ClassPrivateProperty extends BaseNode {
+  type: "ClassPrivateProperty";
+  key: PrivateName;
+  value: Expression | null;
+  decorators: Decorator[] | null;
+  static: boolean;
+  definite: boolean | null;
+  optional: boolean | null;
+  readonly: boolean | null;
+  typeAnnotation: TypeAnnotation | TSTypeAnnotation | Noop | null;
+  variance: Variance | null;
+}
+interface ClassPrivateMethod extends BaseNode {
+  type: "ClassPrivateMethod";
+  kind: "get" | "set" | "method";
+  key: PrivateName;
+  params: (FunctionParameter | TSParameterProperty)[];
+  body: BlockStatement;
+  static: boolean;
+  abstract: boolean | null;
+  access: "public" | "private" | "protected" | null;
+  accessibility: "public" | "private" | "protected" | null;
+  async: boolean;
+  computed: boolean;
+  decorators: Decorator[] | null;
+  generator: boolean;
+  optional: boolean | null;
+  override: boolean;
+  returnType: TypeAnnotation | TSTypeAnnotation | Noop | null;
+  typeParameters: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop | null;
+}
+interface PrivateName extends BaseNode {
+  type: "PrivateName";
+  id: Identifier;
+}
+interface StaticBlock extends BaseNode {
+  type: "StaticBlock";
+  body: Statement[];
+}
+interface ImportAttribute extends BaseNode {
+  type: "ImportAttribute";
+  key: Identifier | StringLiteral;
+  value: StringLiteral;
+}
+interface AnyTypeAnnotation extends BaseNode {
+  type: "AnyTypeAnnotation";
+}
+interface ArrayTypeAnnotation extends BaseNode {
+  type: "ArrayTypeAnnotation";
+  elementType: FlowType;
+}
+interface BooleanTypeAnnotation extends BaseNode {
+  type: "BooleanTypeAnnotation";
+}
+interface BooleanLiteralTypeAnnotation extends BaseNode {
+  type: "BooleanLiteralTypeAnnotation";
+  value: boolean;
+}
+interface NullLiteralTypeAnnotation extends BaseNode {
+  type: "NullLiteralTypeAnnotation";
+}
+interface ClassImplements extends BaseNode {
+  type: "ClassImplements";
+  id: Identifier;
+  typeParameters: TypeParameterInstantiation | null;
+}
+interface DeclareClass extends BaseNode {
+  type: "DeclareClass";
+  id: Identifier;
+  typeParameters: TypeParameterDeclaration | null;
+  extends: InterfaceExtends[] | null;
+  body: ObjectTypeAnnotation;
+  implements: ClassImplements[] | null;
+  mixins: InterfaceExtends[] | null;
+}
+interface DeclareFunction extends BaseNode {
+  type: "DeclareFunction";
+  id: Identifier;
+  predicate: DeclaredPredicate | null;
+}
+interface DeclareInterface extends BaseNode {
+  type: "DeclareInterface";
+  id: Identifier;
+  typeParameters: TypeParameterDeclaration | null;
+  extends: InterfaceExtends[] | null;
+  body: ObjectTypeAnnotation;
+}
+interface DeclareModule extends BaseNode {
+  type: "DeclareModule";
+  id: Identifier | StringLiteral;
+  body: BlockStatement;
+  kind: "CommonJS" | "ES" | null;
+}
+interface DeclareModuleExports extends BaseNode {
+  type: "DeclareModuleExports";
+  typeAnnotation: TypeAnnotation;
+}
+interface DeclareTypeAlias extends BaseNode {
+  type: "DeclareTypeAlias";
+  id: Identifier;
+  typeParameters: TypeParameterDeclaration | null;
+  right: FlowType;
+}
+interface DeclareOpaqueType extends BaseNode {
+  type: "DeclareOpaqueType";
+  id: Identifier;
+  typeParameters: TypeParameterDeclaration | null;
+  supertype: FlowType | null;
+  impltype: FlowType | null;
+}
+interface DeclareVariable extends BaseNode {
+  type: "DeclareVariable";
+  id: Identifier;
+}
+interface DeclareExportDeclaration extends BaseNode {
+  type: "DeclareExportDeclaration";
+  declaration: Flow | null;
+  specifiers: (ExportSpecifier | ExportNamespaceSpecifier)[] | null;
+  source: StringLiteral | null;
+  attributes: ImportAttribute[] | null;
+  assertions: ImportAttribute[] | null;
+  default: boolean | null;
+}
+interface DeclareExportAllDeclaration extends BaseNode {
+  type: "DeclareExportAllDeclaration";
+  source: StringLiteral;
+  attributes: ImportAttribute[] | null;
+  assertions: ImportAttribute[] | null;
+  exportKind: "type" | "value" | null;
+}
+interface DeclaredPredicate extends BaseNode {
+  type: "DeclaredPredicate";
+  value: Flow;
+}
+interface ExistsTypeAnnotation extends BaseNode {
+  type: "ExistsTypeAnnotation";
+}
+interface FunctionTypeAnnotation extends BaseNode {
+  type: "FunctionTypeAnnotation";
+  typeParameters: TypeParameterDeclaration | null;
+  params: FunctionTypeParam[];
+  rest: FunctionTypeParam | null;
+  returnType: FlowType;
+  this: FunctionTypeParam | null;
+}
+interface FunctionTypeParam extends BaseNode {
+  type: "FunctionTypeParam";
+  name: Identifier | null;
+  typeAnnotation: FlowType;
+  optional: boolean | null;
+}
+interface GenericTypeAnnotation extends BaseNode {
+  type: "GenericTypeAnnotation";
+  id: Identifier | QualifiedTypeIdentifier;
+  typeParameters: TypeParameterInstantiation | null;
+}
+interface InferredPredicate extends BaseNode {
+  type: "InferredPredicate";
+}
+interface InterfaceExtends extends BaseNode {
+  type: "InterfaceExtends";
+  id: Identifier | QualifiedTypeIdentifier;
+  typeParameters: TypeParameterInstantiation | null;
+}
+interface InterfaceDeclaration extends BaseNode {
+  type: "InterfaceDeclaration";
+  id: Identifier;
+  typeParameters: TypeParameterDeclaration | null;
+  extends: InterfaceExtends[] | null;
+  body: ObjectTypeAnnotation;
+}
+interface InterfaceTypeAnnotation extends BaseNode {
+  type: "InterfaceTypeAnnotation";
+  extends: InterfaceExtends[] | null;
+  body: ObjectTypeAnnotation;
+}
+interface IntersectionTypeAnnotation extends BaseNode {
+  type: "IntersectionTypeAnnotation";
+  types: FlowType[];
+}
+interface MixedTypeAnnotation extends BaseNode {
+  type: "MixedTypeAnnotation";
+}
+interface EmptyTypeAnnotation extends BaseNode {
+  type: "EmptyTypeAnnotation";
+}
+interface NullableTypeAnnotation extends BaseNode {
+  type: "NullableTypeAnnotation";
+  typeAnnotation: FlowType;
+}
+interface NumberLiteralTypeAnnotation extends BaseNode {
+  type: "NumberLiteralTypeAnnotation";
+  value: number;
+}
+interface NumberTypeAnnotation extends BaseNode {
+  type: "NumberTypeAnnotation";
+}
+interface ObjectTypeAnnotation extends BaseNode {
+  type: "ObjectTypeAnnotation";
+  properties: (ObjectTypeProperty | ObjectTypeSpreadProperty)[];
+  indexers: ObjectTypeIndexer[];
+  callProperties: ObjectTypeCallProperty[];
+  internalSlots: ObjectTypeInternalSlot[];
+  exact: boolean;
+  inexact: boolean | null;
+}
+interface ObjectTypeInternalSlot extends BaseNode {
+  type: "ObjectTypeInternalSlot";
+  id: Identifier;
+  value: FlowType;
+  optional: boolean;
+  static: boolean;
+  method: boolean;
+}
+interface ObjectTypeCallProperty extends BaseNode {
+  type: "ObjectTypeCallProperty";
+  value: FlowType;
+  static: boolean;
+}
+interface ObjectTypeIndexer extends BaseNode {
+  type: "ObjectTypeIndexer";
+  id: Identifier | null;
+  key: FlowType;
+  value: FlowType;
+  variance: Variance | null;
+  static: boolean;
+}
+interface ObjectTypeProperty extends BaseNode {
+  type: "ObjectTypeProperty";
+  key: Identifier | StringLiteral;
+  value: FlowType;
+  variance: Variance | null;
+  kind: "init" | "get" | "set";
+  method: boolean;
+  optional: boolean;
+  proto: boolean;
+  static: boolean;
+}
+interface ObjectTypeSpreadProperty extends BaseNode {
+  type: "ObjectTypeSpreadProperty";
+  argument: FlowType;
+}
+interface OpaqueType extends BaseNode {
+  type: "OpaqueType";
+  id: Identifier;
+  typeParameters: TypeParameterDeclaration | null;
+  supertype: FlowType | null;
+  impltype: FlowType;
+}
+interface QualifiedTypeIdentifier extends BaseNode {
+  type: "QualifiedTypeIdentifier";
+  id: Identifier;
+  qualification: Identifier | QualifiedTypeIdentifier;
+}
+interface StringLiteralTypeAnnotation extends BaseNode {
+  type: "StringLiteralTypeAnnotation";
+  value: string;
+}
+interface StringTypeAnnotation extends BaseNode {
+  type: "StringTypeAnnotation";
+}
+interface SymbolTypeAnnotation extends BaseNode {
+  type: "SymbolTypeAnnotation";
+}
+interface ThisTypeAnnotation extends BaseNode {
+  type: "ThisTypeAnnotation";
+}
+interface TupleTypeAnnotation extends BaseNode {
+  type: "TupleTypeAnnotation";
+  types: FlowType[];
+}
+interface TypeofTypeAnnotation extends BaseNode {
+  type: "TypeofTypeAnnotation";
+  argument: FlowType;
+}
+interface TypeAlias extends BaseNode {
+  type: "TypeAlias";
+  id: Identifier;
+  typeParameters: TypeParameterDeclaration | null;
+  right: FlowType;
+}
+interface TypeAnnotation extends BaseNode {
+  type: "TypeAnnotation";
+  typeAnnotation: FlowType;
+}
+interface TypeCastExpression extends BaseNode {
+  type: "TypeCastExpression";
+  expression: Expression;
+  typeAnnotation: TypeAnnotation;
+}
+interface TypeParameter extends BaseNode {
+  type: "TypeParameter";
+  bound: TypeAnnotation | null;
+  default: FlowType | null;
+  variance: Variance | null;
+  name: string;
+}
+interface TypeParameterDeclaration extends BaseNode {
+  type: "TypeParameterDeclaration";
+  params: TypeParameter[];
+}
+interface TypeParameterInstantiation extends BaseNode {
+  type: "TypeParameterInstantiation";
+  params: FlowType[];
+}
+interface UnionTypeAnnotation extends BaseNode {
+  type: "UnionTypeAnnotation";
+  types: FlowType[];
+}
+interface Variance extends BaseNode {
+  type: "Variance";
+  kind: "minus" | "plus";
+}
+interface VoidTypeAnnotation extends BaseNode {
+  type: "VoidTypeAnnotation";
+}
+interface EnumDeclaration extends BaseNode {
+  type: "EnumDeclaration";
+  id: Identifier;
+  body: EnumBooleanBody | EnumNumberBody | EnumStringBody | EnumSymbolBody;
+}
+interface EnumBooleanBody extends BaseNode {
+  type: "EnumBooleanBody";
+  members: EnumBooleanMember[];
+  explicitType: boolean;
+  hasUnknownMembers: boolean;
+}
+interface EnumNumberBody extends BaseNode {
+  type: "EnumNumberBody";
+  members: EnumNumberMember[];
+  explicitType: boolean;
+  hasUnknownMembers: boolean;
+}
+interface EnumStringBody extends BaseNode {
+  type: "EnumStringBody";
+  members: (EnumStringMember | EnumDefaultedMember)[];
+  explicitType: boolean;
+  hasUnknownMembers: boolean;
+}
+interface EnumSymbolBody extends BaseNode {
+  type: "EnumSymbolBody";
+  members: EnumDefaultedMember[];
+  hasUnknownMembers: boolean;
+}
+interface EnumBooleanMember extends BaseNode {
+  type: "EnumBooleanMember";
+  id: Identifier;
+  init: BooleanLiteral;
+}
+interface EnumNumberMember extends BaseNode {
+  type: "EnumNumberMember";
+  id: Identifier;
+  init: NumericLiteral;
+}
+interface EnumStringMember extends BaseNode {
+  type: "EnumStringMember";
+  id: Identifier;
+  init: StringLiteral;
+}
+interface EnumDefaultedMember extends BaseNode {
+  type: "EnumDefaultedMember";
+  id: Identifier;
+}
+interface IndexedAccessType extends BaseNode {
+  type: "IndexedAccessType";
+  objectType: FlowType;
+  indexType: FlowType;
+}
+interface OptionalIndexedAccessType extends BaseNode {
+  type: "OptionalIndexedAccessType";
+  objectType: FlowType;
+  indexType: FlowType;
+  optional: boolean;
+}
+interface JSXAttribute extends BaseNode {
+  type: "JSXAttribute";
+  name: JSXIdentifier | JSXNamespacedName;
+  value: JSXElement | JSXFragment | StringLiteral | JSXExpressionContainer | null;
+}
+interface JSXClosingElement extends BaseNode {
+  type: "JSXClosingElement";
+  name: JSXIdentifier | JSXMemberExpression | JSXNamespacedName;
+}
+interface JSXElement extends BaseNode {
+  type: "JSXElement";
+  openingElement: JSXOpeningElement;
+  closingElement: JSXClosingElement | null;
+  children: (JSXText | JSXExpressionContainer | JSXSpreadChild | JSXElement | JSXFragment)[];
+  selfClosing: boolean | null;
+}
+interface JSXEmptyExpression extends BaseNode {
+  type: "JSXEmptyExpression";
+}
+interface JSXExpressionContainer extends BaseNode {
+  type: "JSXExpressionContainer";
+  expression: Expression | JSXEmptyExpression;
+}
+interface JSXSpreadChild extends BaseNode {
+  type: "JSXSpreadChild";
+  expression: Expression;
+}
+interface JSXIdentifier extends BaseNode {
+  type: "JSXIdentifier";
+  name: string;
+}
+interface JSXMemberExpression extends BaseNode {
+  type: "JSXMemberExpression";
+  object: JSXMemberExpression | JSXIdentifier;
+  property: JSXIdentifier;
+}
+interface JSXNamespacedName extends BaseNode {
+  type: "JSXNamespacedName";
+  namespace: JSXIdentifier;
+  name: JSXIdentifier;
+}
+interface JSXOpeningElement extends BaseNode {
+  type: "JSXOpeningElement";
+  name: JSXIdentifier | JSXMemberExpression | JSXNamespacedName;
+  attributes: (JSXAttribute | JSXSpreadAttribute)[];
+  selfClosing: boolean;
+  typeArguments: TypeParameterInstantiation | null;
+  typeParameters: TSTypeParameterInstantiation | null;
+}
+interface JSXSpreadAttribute extends BaseNode {
+  type: "JSXSpreadAttribute";
+  argument: Expression;
+}
+interface JSXText extends BaseNode {
+  type: "JSXText";
+  value: string;
+}
+interface JSXFragment extends BaseNode {
+  type: "JSXFragment";
+  openingFragment: JSXOpeningFragment;
+  closingFragment: JSXClosingFragment;
+  children: (JSXText | JSXExpressionContainer | JSXSpreadChild | JSXElement | JSXFragment)[];
+}
+interface JSXOpeningFragment extends BaseNode {
+  type: "JSXOpeningFragment";
+}
+interface JSXClosingFragment extends BaseNode {
+  type: "JSXClosingFragment";
+}
+interface Noop extends BaseNode {
+  type: "Noop";
+}
+interface Placeholder extends BaseNode {
+  type: "Placeholder";
+  expectedNode: "Identifier" | "StringLiteral" | "Expression" | "Statement" | "Declaration" | "BlockStatement" | "ClassBody" | "Pattern";
+  name: Identifier;
+  decorators: Decorator[] | null;
+  optional: boolean | null;
+  typeAnnotation: TypeAnnotation | TSTypeAnnotation | Noop | null;
+}
+interface V8IntrinsicIdentifier extends BaseNode {
+  type: "V8IntrinsicIdentifier";
+  name: string;
+}
+interface ArgumentPlaceholder extends BaseNode {
+  type: "ArgumentPlaceholder";
+}
+interface BindExpression extends BaseNode {
+  type: "BindExpression";
+  object: Expression;
+  callee: Expression;
+}
+interface Decorator extends BaseNode {
+  type: "Decorator";
+  expression: Expression;
+}
+interface DoExpression extends BaseNode {
+  type: "DoExpression";
+  body: BlockStatement;
+  async: boolean;
+}
+interface ExportDefaultSpecifier extends BaseNode {
+  type: "ExportDefaultSpecifier";
+  exported: Identifier;
+}
+interface RecordExpression extends BaseNode {
+  type: "RecordExpression";
+  properties: (ObjectProperty | SpreadElement)[];
+}
+interface TupleExpression extends BaseNode {
+  type: "TupleExpression";
+  elements: (Expression | SpreadElement)[];
+}
+interface DecimalLiteral extends BaseNode {
+  type: "DecimalLiteral";
+  value: string;
+}
+interface ModuleExpression extends BaseNode {
+  type: "ModuleExpression";
+  body: Program;
+}
+interface TopicReference extends BaseNode {
+  type: "TopicReference";
+}
+interface PipelineTopicExpression extends BaseNode {
+  type: "PipelineTopicExpression";
+  expression: Expression;
+}
+interface PipelineBareFunction extends BaseNode {
+  type: "PipelineBareFunction";
+  callee: Expression;
+}
+interface PipelinePrimaryTopicReference extends BaseNode {
+  type: "PipelinePrimaryTopicReference";
+}
+interface VoidPattern extends BaseNode {
+  type: "VoidPattern";
+}
+interface TSParameterProperty extends BaseNode {
+  type: "TSParameterProperty";
+  parameter: Identifier | AssignmentPattern;
+  accessibility: "public" | "private" | "protected" | null;
+  decorators: Decorator[] | null;
+  override: boolean | null;
+  readonly: boolean | null;
+}
+interface TSDeclareFunction extends BaseNode {
+  type: "TSDeclareFunction";
+  id: Identifier | null;
+  typeParameters: TSTypeParameterDeclaration | Noop | null;
+  params: FunctionParameter[];
+  returnType: TSTypeAnnotation | Noop | null;
+  async: boolean;
+  declare: boolean | null;
+  generator: boolean;
+}
+interface TSDeclareMethod extends BaseNode {
+  type: "TSDeclareMethod";
+  decorators: Decorator[] | null;
+  key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | Expression;
+  typeParameters: TSTypeParameterDeclaration | Noop | null;
+  params: (FunctionParameter | TSParameterProperty)[];
+  returnType: TSTypeAnnotation | Noop | null;
+  abstract: boolean | null;
+  access: "public" | "private" | "protected" | null;
+  accessibility: "public" | "private" | "protected" | null;
+  async: boolean;
+  computed: boolean;
+  generator: boolean;
+  kind: "get" | "set" | "method" | "constructor";
+  optional: boolean | null;
+  override: boolean;
+  static: boolean;
+}
+interface TSQualifiedName extends BaseNode {
+  type: "TSQualifiedName";
+  left: TSEntityName;
+  right: Identifier;
+}
+interface TSCallSignatureDeclaration extends BaseNode {
+  type: "TSCallSignatureDeclaration";
+  typeParameters: TSTypeParameterDeclaration | null;
+  parameters: (ArrayPattern | Identifier | ObjectPattern | RestElement)[];
+  typeAnnotation: TSTypeAnnotation | null;
+}
+interface TSConstructSignatureDeclaration extends BaseNode {
+  type: "TSConstructSignatureDeclaration";
+  typeParameters: TSTypeParameterDeclaration | null;
+  parameters: (ArrayPattern | Identifier | ObjectPattern | RestElement)[];
+  typeAnnotation: TSTypeAnnotation | null;
+}
+interface TSPropertySignature extends BaseNode {
+  type: "TSPropertySignature";
+  key: Expression;
+  typeAnnotation: TSTypeAnnotation | null;
+  computed: boolean;
+  kind: "get" | "set" | null;
+  optional: boolean | null;
+  readonly: boolean | null;
+}
+interface TSMethodSignature extends BaseNode {
+  type: "TSMethodSignature";
+  key: Expression;
+  typeParameters: TSTypeParameterDeclaration | null;
+  parameters: (ArrayPattern | Identifier | ObjectPattern | RestElement)[];
+  typeAnnotation: TSTypeAnnotation | null;
+  computed: boolean;
+  kind: "method" | "get" | "set";
+  optional: boolean | null;
+}
+interface TSIndexSignature extends BaseNode {
+  type: "TSIndexSignature";
+  parameters: Identifier[];
+  typeAnnotation: TSTypeAnnotation | null;
+  readonly: boolean | null;
+  static: boolean | null;
+}
+interface TSAnyKeyword extends BaseNode {
+  type: "TSAnyKeyword";
+}
+interface TSBooleanKeyword extends BaseNode {
+  type: "TSBooleanKeyword";
+}
+interface TSBigIntKeyword extends BaseNode {
+  type: "TSBigIntKeyword";
+}
+interface TSIntrinsicKeyword extends BaseNode {
+  type: "TSIntrinsicKeyword";
+}
+interface TSNeverKeyword extends BaseNode {
+  type: "TSNeverKeyword";
+}
+interface TSNullKeyword extends BaseNode {
+  type: "TSNullKeyword";
+}
+interface TSNumberKeyword extends BaseNode {
+  type: "TSNumberKeyword";
+}
+interface TSObjectKeyword extends BaseNode {
+  type: "TSObjectKeyword";
+}
+interface TSStringKeyword extends BaseNode {
+  type: "TSStringKeyword";
+}
+interface TSSymbolKeyword extends BaseNode {
+  type: "TSSymbolKeyword";
+}
+interface TSUndefinedKeyword extends BaseNode {
+  type: "TSUndefinedKeyword";
+}
+interface TSUnknownKeyword extends BaseNode {
+  type: "TSUnknownKeyword";
+}
+interface TSVoidKeyword extends BaseNode {
+  type: "TSVoidKeyword";
+}
+interface TSThisType extends BaseNode {
+  type: "TSThisType";
+}
+interface TSFunctionType extends BaseNode {
+  type: "TSFunctionType";
+  typeParameters: TSTypeParameterDeclaration | null;
+  parameters: (ArrayPattern | Identifier | ObjectPattern | RestElement)[];
+  typeAnnotation: TSTypeAnnotation | null;
+}
+interface TSConstructorType extends BaseNode {
+  type: "TSConstructorType";
+  typeParameters: TSTypeParameterDeclaration | null;
+  parameters: (ArrayPattern | Identifier | ObjectPattern | RestElement)[];
+  typeAnnotation: TSTypeAnnotation | null;
+  abstract: boolean | null;
+}
+interface TSTypeReference extends BaseNode {
+  type: "TSTypeReference";
+  typeName: TSEntityName;
+  typeParameters: TSTypeParameterInstantiation | null;
+}
+interface TSTypePredicate extends BaseNode {
+  type: "TSTypePredicate";
+  parameterName: Identifier | TSThisType;
+  typeAnnotation: TSTypeAnnotation | null;
+  asserts: boolean | null;
+}
+interface TSTypeQuery extends BaseNode {
+  type: "TSTypeQuery";
+  exprName: TSEntityName | TSImportType;
+  typeParameters: TSTypeParameterInstantiation | null;
+}
+interface TSTypeLiteral extends BaseNode {
+  type: "TSTypeLiteral";
+  members: TSTypeElement[];
+}
+interface TSArrayType extends BaseNode {
+  type: "TSArrayType";
+  elementType: TSType;
+}
+interface TSTupleType extends BaseNode {
+  type: "TSTupleType";
+  elementTypes: (TSType | TSNamedTupleMember)[];
+}
+interface TSOptionalType extends BaseNode {
+  type: "TSOptionalType";
+  typeAnnotation: TSType;
+}
+interface TSRestType extends BaseNode {
+  type: "TSRestType";
+  typeAnnotation: TSType;
+}
+interface TSNamedTupleMember extends BaseNode {
+  type: "TSNamedTupleMember";
+  label: Identifier;
+  elementType: TSType;
+  optional: boolean;
+}
+interface TSUnionType extends BaseNode {
+  type: "TSUnionType";
+  types: TSType[];
+}
+interface TSIntersectionType extends BaseNode {
+  type: "TSIntersectionType";
+  types: TSType[];
+}
+interface TSConditionalType extends BaseNode {
+  type: "TSConditionalType";
+  checkType: TSType;
+  extendsType: TSType;
+  trueType: TSType;
+  falseType: TSType;
+}
+interface TSInferType extends BaseNode {
+  type: "TSInferType";
+  typeParameter: TSTypeParameter;
+}
+interface TSParenthesizedType extends BaseNode {
+  type: "TSParenthesizedType";
+  typeAnnotation: TSType;
+}
+interface TSTypeOperator extends BaseNode {
+  type: "TSTypeOperator";
+  typeAnnotation: TSType;
+  operator: string;
+}
+interface TSIndexedAccessType extends BaseNode {
+  type: "TSIndexedAccessType";
+  objectType: TSType;
+  indexType: TSType;
+}
+interface TSMappedType extends BaseNode {
+  type: "TSMappedType";
+  typeParameter: TSTypeParameter;
+  typeAnnotation: TSType | null;
+  nameType: TSType | null;
+  optional: true | false | "+" | "-" | null;
+  readonly: true | false | "+" | "-" | null;
+}
+interface TSTemplateLiteralType extends BaseNode {
+  type: "TSTemplateLiteralType";
+  quasis: TemplateElement[];
+  types: TSType[];
+}
+interface TSLiteralType extends BaseNode {
+  type: "TSLiteralType";
+  literal: NumericLiteral | StringLiteral | BooleanLiteral | BigIntLiteral | TemplateLiteral | UnaryExpression;
+}
+interface TSExpressionWithTypeArguments extends BaseNode {
+  type: "TSExpressionWithTypeArguments";
+  expression: TSEntityName;
+  typeParameters: TSTypeParameterInstantiation | null;
+}
+interface TSInterfaceDeclaration extends BaseNode {
+  type: "TSInterfaceDeclaration";
+  id: Identifier;
+  typeParameters: TSTypeParameterDeclaration | null;
+  extends: TSExpressionWithTypeArguments[] | null;
+  body: TSInterfaceBody;
+  declare: boolean | null;
+}
+interface TSInterfaceBody extends BaseNode {
+  type: "TSInterfaceBody";
+  body: TSTypeElement[];
+}
+interface TSTypeAliasDeclaration extends BaseNode {
+  type: "TSTypeAliasDeclaration";
+  id: Identifier;
+  typeParameters: TSTypeParameterDeclaration | null;
+  typeAnnotation: TSType;
+  declare: boolean | null;
+}
+interface TSInstantiationExpression extends BaseNode {
+  type: "TSInstantiationExpression";
+  expression: Expression;
+  typeParameters: TSTypeParameterInstantiation | null;
+}
+interface TSAsExpression extends BaseNode {
+  type: "TSAsExpression";
+  expression: Expression;
+  typeAnnotation: TSType;
+}
+interface TSSatisfiesExpression extends BaseNode {
+  type: "TSSatisfiesExpression";
+  expression: Expression;
+  typeAnnotation: TSType;
+}
+interface TSTypeAssertion extends BaseNode {
+  type: "TSTypeAssertion";
+  typeAnnotation: TSType;
+  expression: Expression;
+}
+interface TSEnumBody extends BaseNode {
+  type: "TSEnumBody";
+  members: TSEnumMember[];
+}
+interface TSEnumDeclaration extends BaseNode {
+  type: "TSEnumDeclaration";
+  id: Identifier;
+  members: TSEnumMember[];
+  body: TSEnumBody | null;
+  const: boolean | null;
+  declare: boolean | null;
+  initializer: Expression | null;
+}
+interface TSEnumMember extends BaseNode {
+  type: "TSEnumMember";
+  id: Identifier | StringLiteral;
+  initializer: Expression | null;
+}
+interface TSModuleDeclaration extends BaseNode {
+  type: "TSModuleDeclaration";
+  id: Identifier | StringLiteral;
+  body: TSModuleBlock | TSModuleDeclaration;
+  declare: boolean | null;
+  global: boolean | null;
+  kind: "global" | "module" | "namespace";
+}
+interface TSModuleBlock extends BaseNode {
+  type: "TSModuleBlock";
+  body: Statement[];
+}
+interface TSImportType extends BaseNode {
+  type: "TSImportType";
+  argument: StringLiteral;
+  qualifier: TSEntityName | null;
+  typeParameters: TSTypeParameterInstantiation | null;
+  options: ObjectExpression | null;
+}
+interface TSImportEqualsDeclaration extends BaseNode {
+  type: "TSImportEqualsDeclaration";
+  id: Identifier;
+  moduleReference: TSEntityName | TSExternalModuleReference;
+  importKind: "type" | "value" | null;
+  isExport: boolean;
+}
+interface TSExternalModuleReference extends BaseNode {
+  type: "TSExternalModuleReference";
+  expression: StringLiteral;
+}
+interface TSNonNullExpression extends BaseNode {
+  type: "TSNonNullExpression";
+  expression: Expression;
+}
+interface TSExportAssignment extends BaseNode {
+  type: "TSExportAssignment";
+  expression: Expression;
+}
+interface TSNamespaceExportDeclaration extends BaseNode {
+  type: "TSNamespaceExportDeclaration";
+  id: Identifier;
+}
+interface TSTypeAnnotation extends BaseNode {
+  type: "TSTypeAnnotation";
+  typeAnnotation: TSType;
+}
+interface TSTypeParameterInstantiation extends BaseNode {
+  type: "TSTypeParameterInstantiation";
+  params: TSType[];
+}
+interface TSTypeParameterDeclaration extends BaseNode {
+  type: "TSTypeParameterDeclaration";
+  params: TSTypeParameter[];
+}
+interface TSTypeParameter extends BaseNode {
+  type: "TSTypeParameter";
+  constraint: TSType | null;
+  default: TSType | null;
+  name: string;
+  const: boolean | null;
+  in: boolean | null;
+  out: boolean | null;
+}
+/**
+ * @deprecated Use `NumericLiteral`
+ */
+type NumberLiteral = NumericLiteral;
+/**
+ * @deprecated Use `RegExpLiteral`
+ */
+type RegexLiteral = RegExpLiteral;
+/**
+ * @deprecated Use `RestElement`
+ */
+type RestProperty = RestElement;
+/**
+ * @deprecated Use `SpreadElement`
+ */
+type SpreadProperty = SpreadElement;
+type Standardized = ArrayExpression | AssignmentExpression | BinaryExpression | InterpreterDirective | Directive | DirectiveLiteral | BlockStatement | BreakStatement | CallExpression | CatchClause | ConditionalExpression | ContinueStatement | DebuggerStatement | DoWhileStatement | EmptyStatement | ExpressionStatement | File | ForInStatement | ForStatement | FunctionDeclaration | FunctionExpression | Identifier | IfStatement | LabeledStatement | StringLiteral | NumericLiteral | NullLiteral | BooleanLiteral | RegExpLiteral | LogicalExpression | MemberExpression | NewExpression | Program | ObjectExpression | ObjectMethod | ObjectProperty | RestElement | ReturnStatement | SequenceExpression | ParenthesizedExpression | SwitchCase | SwitchStatement | ThisExpression | ThrowStatement | TryStatement | UnaryExpression | UpdateExpression | VariableDeclaration | VariableDeclarator | WhileStatement | WithStatement | AssignmentPattern | ArrayPattern | ArrowFunctionExpression | ClassBody | ClassExpression | ClassDeclaration | ExportAllDeclaration | ExportDefaultDeclaration | ExportNamedDeclaration | ExportSpecifier | ForOfStatement | ImportDeclaration | ImportDefaultSpecifier | ImportNamespaceSpecifier | ImportSpecifier | ImportExpression | MetaProperty | ClassMethod | ObjectPattern | SpreadElement | Super | TaggedTemplateExpression | TemplateElement | TemplateLiteral | YieldExpression | AwaitExpression | Import | BigIntLiteral | ExportNamespaceSpecifier | OptionalMemberExpression | OptionalCallExpression | ClassProperty | ClassAccessorProperty | ClassPrivateProperty | ClassPrivateMethod | PrivateName | StaticBlock | ImportAttribute;
+type Expression = ArrayExpression | AssignmentExpression | BinaryExpression | CallExpression | ConditionalExpression | FunctionExpression | Identifier | StringLiteral | NumericLiteral | NullLiteral | BooleanLiteral | RegExpLiteral | LogicalExpression | MemberExpression | NewExpression | ObjectExpression | SequenceExpression | ParenthesizedExpression | ThisExpression | UnaryExpression | UpdateExpression | ArrowFunctionExpression | ClassExpression | ImportExpression | MetaProperty | Super | TaggedTemplateExpression | TemplateLiteral | YieldExpression | AwaitExpression | Import | BigIntLiteral | OptionalMemberExpression | OptionalCallExpression | TypeCastExpression | JSXElement | JSXFragment | BindExpression | DoExpression | RecordExpression | TupleExpression | DecimalLiteral | ModuleExpression | TopicReference | PipelineTopicExpression | PipelineBareFunction | PipelinePrimaryTopicReference | TSInstantiationExpression | TSAsExpression | TSSatisfiesExpression | TSTypeAssertion | TSNonNullExpression;
+type Binary = BinaryExpression | LogicalExpression;
+type Scopable = BlockStatement | CatchClause | DoWhileStatement | ForInStatement | ForStatement | FunctionDeclaration | FunctionExpression | Program | ObjectMethod | SwitchStatement | WhileStatement | ArrowFunctionExpression | ClassExpression | ClassDeclaration | ForOfStatement | ClassMethod | ClassPrivateMethod | StaticBlock | TSModuleBlock;
+type BlockParent = BlockStatement | CatchClause | DoWhileStatement | ForInStatement | ForStatement | FunctionDeclaration | FunctionExpression | Program | ObjectMethod | SwitchStatement | WhileStatement | ArrowFunctionExpression | ForOfStatement | ClassMethod | ClassPrivateMethod | StaticBlock | TSModuleBlock;
+type Block = BlockStatement | Program | TSModuleBlock;
+type Statement = BlockStatement | BreakStatement | ContinueStatement | DebuggerStatement | DoWhileStatement | EmptyStatement | ExpressionStatement | ForInStatement | ForStatement | FunctionDeclaration | IfStatement | LabeledStatement | ReturnStatement | SwitchStatement | ThrowStatement | TryStatement | VariableDeclaration | WhileStatement | WithStatement | ClassDeclaration | ExportAllDeclaration | ExportDefaultDeclaration | ExportNamedDeclaration | ForOfStatement | ImportDeclaration | DeclareClass | DeclareFunction | DeclareInterface | DeclareModule | DeclareModuleExports | DeclareTypeAlias | DeclareOpaqueType | DeclareVariable | DeclareExportDeclaration | DeclareExportAllDeclaration | InterfaceDeclaration | OpaqueType | TypeAlias | EnumDeclaration | TSDeclareFunction | TSInterfaceDeclaration | TSTypeAliasDeclaration | TSEnumDeclaration | TSModuleDeclaration | TSImportEqualsDeclaration | TSExportAssignment | TSNamespaceExportDeclaration;
+type Terminatorless = BreakStatement | ContinueStatement | ReturnStatement | ThrowStatement | YieldExpression | AwaitExpression;
+type CompletionStatement = BreakStatement | ContinueStatement | ReturnStatement | ThrowStatement;
+type Conditional = ConditionalExpression | IfStatement;
+type Loop = DoWhileStatement | ForInStatement | ForStatement | WhileStatement | ForOfStatement;
+type While = DoWhileStatement | WhileStatement;
+type ExpressionWrapper = ExpressionStatement | ParenthesizedExpression | TypeCastExpression;
+type For = ForInStatement | ForStatement | ForOfStatement;
+type ForXStatement = ForInStatement | ForOfStatement;
+type Function = FunctionDeclaration | FunctionExpression | ObjectMethod | ArrowFunctionExpression | ClassMethod | ClassPrivateMethod;
+type FunctionParent = FunctionDeclaration | FunctionExpression | ObjectMethod | ArrowFunctionExpression | ClassMethod | ClassPrivateMethod | StaticBlock | TSModuleBlock;
+type Pureish = FunctionDeclaration | FunctionExpression | StringLiteral | NumericLiteral | NullLiteral | BooleanLiteral | RegExpLiteral | ArrowFunctionExpression | BigIntLiteral | DecimalLiteral;
+type Declaration = FunctionDeclaration | VariableDeclaration | ClassDeclaration | ExportAllDeclaration | ExportDefaultDeclaration | ExportNamedDeclaration | ImportDeclaration | DeclareClass | DeclareFunction | DeclareInterface | DeclareModule | DeclareModuleExports | DeclareTypeAlias | DeclareOpaqueType | DeclareVariable | DeclareExportDeclaration | DeclareExportAllDeclaration | InterfaceDeclaration | OpaqueType | TypeAlias | EnumDeclaration | TSDeclareFunction | TSInterfaceDeclaration | TSTypeAliasDeclaration | TSEnumDeclaration | TSModuleDeclaration | TSImportEqualsDeclaration;
+type FunctionParameter = Identifier | RestElement | AssignmentPattern | ArrayPattern | ObjectPattern | VoidPattern;
+type PatternLike = Identifier | MemberExpression | RestElement | AssignmentPattern | ArrayPattern | ObjectPattern | VoidPattern | TSAsExpression | TSSatisfiesExpression | TSTypeAssertion | TSNonNullExpression;
+type LVal = Identifier | MemberExpression | RestElement | AssignmentPattern | ArrayPattern | ObjectPattern | TSParameterProperty | TSAsExpression | TSSatisfiesExpression | TSTypeAssertion | TSNonNullExpression;
+type TSEntityName = Identifier | TSQualifiedName;
+type Literal = StringLiteral | NumericLiteral | NullLiteral | BooleanLiteral | RegExpLiteral | TemplateLiteral | BigIntLiteral | DecimalLiteral;
+type Immutable = StringLiteral | NumericLiteral | NullLiteral | BooleanLiteral | BigIntLiteral | JSXAttribute | JSXClosingElement | JSXElement | JSXExpressionContainer | JSXSpreadChild | JSXOpeningElement | JSXText | JSXFragment | JSXOpeningFragment | JSXClosingFragment | DecimalLiteral;
+type UserWhitespacable = ObjectMethod | ObjectProperty | ObjectTypeInternalSlot | ObjectTypeCallProperty | ObjectTypeIndexer | ObjectTypeProperty | ObjectTypeSpreadProperty;
+type Method = ObjectMethod | ClassMethod | ClassPrivateMethod;
+type ObjectMember = ObjectMethod | ObjectProperty;
+type Property = ObjectProperty | ClassProperty | ClassAccessorProperty | ClassPrivateProperty;
+type UnaryLike = UnaryExpression | SpreadElement;
+type Pattern = AssignmentPattern | ArrayPattern | ObjectPattern | VoidPattern;
+type Class = ClassExpression | ClassDeclaration;
+type ImportOrExportDeclaration = ExportAllDeclaration | ExportDefaultDeclaration | ExportNamedDeclaration | ImportDeclaration;
+type ExportDeclaration = ExportAllDeclaration | ExportDefaultDeclaration | ExportNamedDeclaration;
+type ModuleSpecifier = ExportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier | ImportSpecifier | ExportNamespaceSpecifier | ExportDefaultSpecifier;
+type Accessor = ClassAccessorProperty;
+type Private = ClassPrivateProperty | ClassPrivateMethod | PrivateName;
+type Flow = AnyTypeAnnotation | ArrayTypeAnnotation | BooleanTypeAnnotation | BooleanLiteralTypeAnnotation | NullLiteralTypeAnnotation | ClassImplements | DeclareClass | DeclareFunction | DeclareInterface | DeclareModule | DeclareModuleExports | DeclareTypeAlias | DeclareOpaqueType | DeclareVariable | DeclareExportDeclaration | DeclareExportAllDeclaration | DeclaredPredicate | ExistsTypeAnnotation | FunctionTypeAnnotation | FunctionTypeParam | GenericTypeAnnotation | InferredPredicate | InterfaceExtends | InterfaceDeclaration | InterfaceTypeAnnotation | IntersectionTypeAnnotation | MixedTypeAnnotation | EmptyTypeAnnotation | NullableTypeAnnotation | NumberLiteralTypeAnnotation | NumberTypeAnnotation | ObjectTypeAnnotation | ObjectTypeInternalSlot | ObjectTypeCallProperty | ObjectTypeIndexer | ObjectTypeProperty | ObjectTypeSpreadProperty | OpaqueType | QualifiedTypeIdentifier | StringLiteralTypeAnnotation | StringTypeAnnotation | SymbolTypeAnnotation | ThisTypeAnnotation | TupleTypeAnnotation | TypeofTypeAnnotation | TypeAlias | TypeAnnotation | TypeCastExpression | TypeParameter | TypeParameterDeclaration | TypeParameterInstantiation | UnionTypeAnnotation | Variance | VoidTypeAnnotation | EnumDeclaration | EnumBooleanBody | EnumNumberBody | EnumStringBody | EnumSymbolBody | EnumBooleanMember | EnumNumberMember | EnumStringMember | EnumDefaultedMember | IndexedAccessType | OptionalIndexedAccessType;
+type FlowType = AnyTypeAnnotation | ArrayTypeAnnotation | BooleanTypeAnnotation | BooleanLiteralTypeAnnotation | NullLiteralTypeAnnotation | ExistsTypeAnnotation | FunctionTypeAnnotation | GenericTypeAnnotation | InterfaceTypeAnnotation | IntersectionTypeAnnotation | MixedTypeAnnotation | EmptyTypeAnnotation | NullableTypeAnnotation | NumberLiteralTypeAnnotation | NumberTypeAnnotation | ObjectTypeAnnotation | StringLiteralTypeAnnotation | StringTypeAnnotation | SymbolTypeAnnotation | ThisTypeAnnotation | TupleTypeAnnotation | TypeofTypeAnnotation | UnionTypeAnnotation | VoidTypeAnnotation | IndexedAccessType | OptionalIndexedAccessType;
+type FlowBaseAnnotation = AnyTypeAnnotation | BooleanTypeAnnotation | NullLiteralTypeAnnotation | MixedTypeAnnotation | EmptyTypeAnnotation | NumberTypeAnnotation | StringTypeAnnotation | SymbolTypeAnnotation | ThisTypeAnnotation | VoidTypeAnnotation;
+type FlowDeclaration = DeclareClass | DeclareFunction | DeclareInterface | DeclareModule | DeclareModuleExports | DeclareTypeAlias | DeclareOpaqueType | DeclareVariable | DeclareExportDeclaration | DeclareExportAllDeclaration | InterfaceDeclaration | OpaqueType | TypeAlias;
+type FlowPredicate = DeclaredPredicate | InferredPredicate;
+type EnumBody = EnumBooleanBody | EnumNumberBody | EnumStringBody | EnumSymbolBody;
+type EnumMember = EnumBooleanMember | EnumNumberMember | EnumStringMember | EnumDefaultedMember;
+type JSX = JSXAttribute | JSXClosingElement | JSXElement | JSXEmptyExpression | JSXExpressionContainer | JSXSpreadChild | JSXIdentifier | JSXMemberExpression | JSXNamespacedName | JSXOpeningElement | JSXSpreadAttribute | JSXText | JSXFragment | JSXOpeningFragment | JSXClosingFragment;
+type Miscellaneous = Noop | Placeholder | V8IntrinsicIdentifier;
+type TypeScript = TSParameterProperty | TSDeclareFunction | TSDeclareMethod | TSQualifiedName | TSCallSignatureDeclaration | TSConstructSignatureDeclaration | TSPropertySignature | TSMethodSignature | TSIndexSignature | TSAnyKeyword | TSBooleanKeyword | TSBigIntKeyword | TSIntrinsicKeyword | TSNeverKeyword | TSNullKeyword | TSNumberKeyword | TSObjectKeyword | TSStringKeyword | TSSymbolKeyword | TSUndefinedKeyword | TSUnknownKeyword | TSVoidKeyword | TSThisType | TSFunctionType | TSConstructorType | TSTypeReference | TSTypePredicate | TSTypeQuery | TSTypeLiteral | TSArrayType | TSTupleType | TSOptionalType | TSRestType | TSNamedTupleMember | TSUnionType | TSIntersectionType | TSConditionalType | TSInferType | TSParenthesizedType | TSTypeOperator | TSIndexedAccessType | TSMappedType | TSTemplateLiteralType | TSLiteralType | TSExpressionWithTypeArguments | TSInterfaceDeclaration | TSInterfaceBody | TSTypeAliasDeclaration | TSInstantiationExpression | TSAsExpression | TSSatisfiesExpression | TSTypeAssertion | TSEnumBody | TSEnumDeclaration | TSEnumMember | TSModuleDeclaration | TSModuleBlock | TSImportType | TSImportEqualsDeclaration | TSExternalModuleReference | TSNonNullExpression | TSExportAssignment | TSNamespaceExportDeclaration | TSTypeAnnotation | TSTypeParameterInstantiation | TSTypeParameterDeclaration | TSTypeParameter;
+type TSTypeElement = TSCallSignatureDeclaration | TSConstructSignatureDeclaration | TSPropertySignature | TSMethodSignature | TSIndexSignature;
+type TSType = TSAnyKeyword | TSBooleanKeyword | TSBigIntKeyword | TSIntrinsicKeyword | TSNeverKeyword | TSNullKeyword | TSNumberKeyword | TSObjectKeyword | TSStringKeyword | TSSymbolKeyword | TSUndefinedKeyword | TSUnknownKeyword | TSVoidKeyword | TSThisType | TSFunctionType | TSConstructorType | TSTypeReference | TSTypePredicate | TSTypeQuery | TSTypeLiteral | TSArrayType | TSTupleType | TSOptionalType | TSRestType | TSUnionType | TSIntersectionType | TSConditionalType | TSInferType | TSParenthesizedType | TSTypeOperator | TSIndexedAccessType | TSMappedType | TSTemplateLiteralType | TSLiteralType | TSExpressionWithTypeArguments | TSImportType;
+type TSBaseType = TSAnyKeyword | TSBooleanKeyword | TSBigIntKeyword | TSIntrinsicKeyword | TSNeverKeyword | TSNullKeyword | TSNumberKeyword | TSObjectKeyword | TSStringKeyword | TSSymbolKeyword | TSUndefinedKeyword | TSUnknownKeyword | TSVoidKeyword | TSThisType | TSTemplateLiteralType | TSLiteralType;
+type ModuleDeclaration = ExportAllDeclaration | ExportDefaultDeclaration | ExportNamedDeclaration | ImportDeclaration;
+interface Aliases {
+  Standardized: Standardized;
+  Expression: Expression;
+  Binary: Binary;
+  Scopable: Scopable;
+  BlockParent: BlockParent;
+  Block: Block;
+  Statement: Statement;
+  Terminatorless: Terminatorless;
+  CompletionStatement: CompletionStatement;
+  Conditional: Conditional;
+  Loop: Loop;
+  While: While;
+  ExpressionWrapper: ExpressionWrapper;
+  For: For;
+  ForXStatement: ForXStatement;
+  Function: Function;
+  FunctionParent: FunctionParent;
+  Pureish: Pureish;
+  Declaration: Declaration;
+  FunctionParameter: FunctionParameter;
+  PatternLike: PatternLike;
+  LVal: LVal;
+  TSEntityName: TSEntityName;
+  Literal: Literal;
+  Immutable: Immutable;
+  UserWhitespacable: UserWhitespacable;
+  Method: Method;
+  ObjectMember: ObjectMember;
+  Property: Property;
+  UnaryLike: UnaryLike;
+  Pattern: Pattern;
+  Class: Class;
+  ImportOrExportDeclaration: ImportOrExportDeclaration;
+  ExportDeclaration: ExportDeclaration;
+  ModuleSpecifier: ModuleSpecifier;
+  Accessor: Accessor;
+  Private: Private;
+  Flow: Flow;
+  FlowType: FlowType;
+  FlowBaseAnnotation: FlowBaseAnnotation;
+  FlowDeclaration: FlowDeclaration;
+  FlowPredicate: FlowPredicate;
+  EnumBody: EnumBody;
+  EnumMember: EnumMember;
+  JSX: JSX;
+  Miscellaneous: Miscellaneous;
+  TypeScript: TypeScript;
+  TSTypeElement: TSTypeElement;
+  TSType: TSType;
+  TSBaseType: TSBaseType;
+  ModuleDeclaration: ModuleDeclaration;
+}
+declare function arrayExpression(elements?: (null | Expression | SpreadElement)[]): ArrayExpression;
+declare function assignmentExpression(operator: string, left: LVal | OptionalMemberExpression, right: Expression): AssignmentExpression;
+declare function binaryExpression(operator: "+" | "-" | "/" | "%" | "*" | "**" | "&" | "|" | ">>" | ">>>" | "<<" | "^" | "==" | "===" | "!=" | "!==" | "in" | "instanceof" | ">" | "<" | ">=" | "<=" | "|>", left: Expression | PrivateName, right: Expression): BinaryExpression;
+declare function interpreterDirective(value: string): InterpreterDirective;
+declare function directive(value: DirectiveLiteral): Directive;
+declare function directiveLiteral(value: string): DirectiveLiteral;
+declare function blockStatement(body: Statement[], directives?: Directive[]): BlockStatement;
+declare function breakStatement(label?: Identifier | null): BreakStatement;
+declare function callExpression(callee: Expression | Super | V8IntrinsicIdentifier, _arguments: (Expression | SpreadElement | ArgumentPlaceholder)[]): CallExpression;
+declare function catchClause(param: Identifier | ArrayPattern | ObjectPattern | null | undefined, body: BlockStatement): CatchClause;
+declare function conditionalExpression(test: Expression, consequent: Expression, alternate: Expression): ConditionalExpression;
+declare function continueStatement(label?: Identifier | null): ContinueStatement;
+declare function debuggerStatement(): DebuggerStatement;
+declare function doWhileStatement(test: Expression, body: Statement): DoWhileStatement;
+declare function emptyStatement(): EmptyStatement;
+declare function expressionStatement(expression: Expression): ExpressionStatement;
+declare function file(program: Program, comments?: (CommentBlock | CommentLine)[] | null, tokens?: any[] | null): File;
+declare function forInStatement(left: VariableDeclaration | LVal, right: Expression, body: Statement): ForInStatement;
+declare function forStatement(init: VariableDeclaration | Expression | null | undefined, test: Expression | null | undefined, update: Expression | null | undefined, body: Statement): ForStatement;
+declare function functionDeclaration(id: Identifier | null | undefined, params: FunctionParameter[], body: BlockStatement, generator?: boolean, async?: boolean): FunctionDeclaration;
+declare function functionExpression(id: Identifier | null | undefined, params: FunctionParameter[], body: BlockStatement, generator?: boolean, async?: boolean): FunctionExpression;
+declare function identifier(name: string): Identifier;
+declare function ifStatement(test: Expression, consequent: Statement, alternate?: Statement | null): IfStatement;
+declare function labeledStatement(label: Identifier, body: Statement): LabeledStatement;
+declare function stringLiteral(value: string): StringLiteral;
+declare function numericLiteral(value: number): NumericLiteral;
+declare function nullLiteral(): NullLiteral;
+declare function booleanLiteral(value: boolean): BooleanLiteral;
+declare function regExpLiteral(pattern: string, flags?: string): RegExpLiteral;
+declare function logicalExpression(operator: "||" | "&&" | "??", left: Expression, right: Expression): LogicalExpression;
+declare function memberExpression(object: Expression | Super, property: Expression | Identifier | PrivateName, computed?: boolean, optional?: boolean | null): MemberExpression;
+declare function newExpression(callee: Expression | Super | V8IntrinsicIdentifier, _arguments: (Expression | SpreadElement | ArgumentPlaceholder)[]): NewExpression;
+declare function program(body: Statement[], directives?: Directive[], sourceType?: "script" | "module", interpreter?: InterpreterDirective | null): Program;
+declare function objectExpression(properties: (ObjectMethod | ObjectProperty | SpreadElement)[]): ObjectExpression;
+declare function objectMethod(kind: "method" | "get" | "set" | undefined, key: Expression | Identifier | StringLiteral | NumericLiteral | BigIntLiteral, params: FunctionParameter[], body: BlockStatement, computed?: boolean, generator?: boolean, async?: boolean): ObjectMethod;
+declare function objectProperty(key: Expression | Identifier | StringLiteral | NumericLiteral | BigIntLiteral | DecimalLiteral | PrivateName, value: Expression | PatternLike, computed?: boolean, shorthand?: boolean, decorators?: Decorator[] | null): ObjectProperty;
+declare function restElement(argument: Identifier | ArrayPattern | ObjectPattern | MemberExpression | TSAsExpression | TSSatisfiesExpression | TSTypeAssertion | TSNonNullExpression | RestElement | AssignmentPattern): RestElement;
+declare function returnStatement(argument?: Expression | null): ReturnStatement;
+declare function sequenceExpression(expressions: Expression[]): SequenceExpression;
+declare function parenthesizedExpression(expression: Expression): ParenthesizedExpression;
+declare function switchCase(test: Expression | null | undefined, consequent: Statement[]): SwitchCase;
+declare function switchStatement(discriminant: Expression, cases: SwitchCase[]): SwitchStatement;
+declare function thisExpression(): ThisExpression;
+declare function throwStatement(argument: Expression): ThrowStatement;
+declare function tryStatement(block: BlockStatement, handler?: CatchClause | null, finalizer?: BlockStatement | null): TryStatement;
+declare function unaryExpression(operator: "void" | "throw" | "delete" | "!" | "+" | "-" | "~" | "typeof", argument: Expression, prefix?: boolean): UnaryExpression;
+declare function updateExpression(operator: "++" | "--", argument: Expression, prefix?: boolean): UpdateExpression;
+declare function variableDeclaration(kind: "var" | "let" | "const" | "using" | "await using", declarations: VariableDeclarator[]): VariableDeclaration;
+declare function variableDeclarator(id: LVal | VoidPattern, init?: Expression | null): VariableDeclarator;
+declare function whileStatement(test: Expression, body: Statement): WhileStatement;
+declare function withStatement(object: Expression, body: Statement): WithStatement;
+declare function assignmentPattern(left: Identifier | ObjectPattern | ArrayPattern | MemberExpression | TSAsExpression | TSSatisfiesExpression | TSTypeAssertion | TSNonNullExpression, right: Expression): AssignmentPattern;
+declare function arrayPattern(elements: (null | PatternLike)[]): ArrayPattern;
+declare function arrowFunctionExpression(params: FunctionParameter[], body: BlockStatement | Expression, async?: boolean): ArrowFunctionExpression;
+declare function classBody(body: (ClassMethod | ClassPrivateMethod | ClassProperty | ClassPrivateProperty | ClassAccessorProperty | TSDeclareMethod | TSIndexSignature | StaticBlock)[]): ClassBody;
+declare function classExpression(id: Identifier | null | undefined, superClass: Expression | null | undefined, body: ClassBody, decorators?: Decorator[] | null): ClassExpression;
+declare function classDeclaration(id: Identifier | null | undefined, superClass: Expression | null | undefined, body: ClassBody, decorators?: Decorator[] | null): ClassDeclaration;
+declare function exportAllDeclaration(source: StringLiteral, attributes?: ImportAttribute[] | null): ExportAllDeclaration;
+declare function exportDefaultDeclaration(declaration: TSDeclareFunction | FunctionDeclaration | ClassDeclaration | Expression): ExportDefaultDeclaration;
+declare function exportNamedDeclaration(declaration?: Declaration | null, specifiers?: (ExportSpecifier | ExportDefaultSpecifier | ExportNamespaceSpecifier)[], source?: StringLiteral | null, attributes?: ImportAttribute[] | null): ExportNamedDeclaration;
+declare function exportSpecifier(local: Identifier, exported: Identifier | StringLiteral): ExportSpecifier;
+declare function forOfStatement(left: VariableDeclaration | LVal, right: Expression, body: Statement, _await?: boolean): ForOfStatement;
+declare function importDeclaration(specifiers: (ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier)[], source: StringLiteral, attributes?: ImportAttribute[] | null): ImportDeclaration;
+declare function importDefaultSpecifier(local: Identifier): ImportDefaultSpecifier;
+declare function importNamespaceSpecifier(local: Identifier): ImportNamespaceSpecifier;
+declare function importSpecifier(local: Identifier, imported: Identifier | StringLiteral): ImportSpecifier;
+declare function importExpression(source: Expression, options?: Expression | null): ImportExpression;
+declare function metaProperty(meta: Identifier, property: Identifier): MetaProperty;
+declare function classMethod(kind: "get" | "set" | "method" | "constructor" | undefined, key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | Expression, params: (FunctionParameter | TSParameterProperty)[], body: BlockStatement, computed?: boolean, _static?: boolean, generator?: boolean, async?: boolean): ClassMethod;
+declare function objectPattern(properties: (RestElement | ObjectProperty)[]): ObjectPattern;
+declare function spreadElement(argument: Expression): SpreadElement;
+declare function _super(): Super;
+declare function taggedTemplateExpression(tag: Expression, quasi: TemplateLiteral): TaggedTemplateExpression;
+declare function templateElement(value: {
+  raw: string;
+  cooked?: string;
+}, tail?: boolean): TemplateElement;
+declare function templateLiteral(quasis: TemplateElement[], expressions: (Expression | TSType)[]): TemplateLiteral;
+declare function yieldExpression(argument?: Expression | null, delegate?: boolean): YieldExpression;
+declare function awaitExpression(argument: Expression): AwaitExpression;
+declare function _import(): Import;
+declare function bigIntLiteral(value: string): BigIntLiteral;
+declare function exportNamespaceSpecifier(exported: Identifier): ExportNamespaceSpecifier;
+declare function optionalMemberExpression(object: Expression, property: Expression | Identifier, computed: boolean | undefined, optional: boolean): OptionalMemberExpression;
+declare function optionalCallExpression(callee: Expression, _arguments: (Expression | SpreadElement | ArgumentPlaceholder)[], optional: boolean): OptionalCallExpression;
+declare function classProperty(key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | Expression, value?: Expression | null, typeAnnotation?: TypeAnnotation | TSTypeAnnotation | Noop | null, decorators?: Decorator[] | null, computed?: boolean, _static?: boolean): ClassProperty;
+declare function classAccessorProperty(key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | Expression | PrivateName, value?: Expression | null, typeAnnotation?: TypeAnnotation | TSTypeAnnotation | Noop | null, decorators?: Decorator[] | null, computed?: boolean, _static?: boolean): ClassAccessorProperty;
+declare function classPrivateProperty(key: PrivateName, value?: Expression | null, decorators?: Decorator[] | null, _static?: boolean): ClassPrivateProperty;
+declare function classPrivateMethod(kind: "get" | "set" | "method" | undefined, key: PrivateName, params: (FunctionParameter | TSParameterProperty)[], body: BlockStatement, _static?: boolean): ClassPrivateMethod;
+declare function privateName(id: Identifier): PrivateName;
+declare function staticBlock(body: Statement[]): StaticBlock;
+declare function importAttribute(key: Identifier | StringLiteral, value: StringLiteral): ImportAttribute;
+declare function anyTypeAnnotation(): AnyTypeAnnotation;
+declare function arrayTypeAnnotation(elementType: FlowType): ArrayTypeAnnotation;
+declare function booleanTypeAnnotation(): BooleanTypeAnnotation;
+declare function booleanLiteralTypeAnnotation(value: boolean): BooleanLiteralTypeAnnotation;
+declare function nullLiteralTypeAnnotation(): NullLiteralTypeAnnotation;
+declare function classImplements(id: Identifier, typeParameters?: TypeParameterInstantiation | null): ClassImplements;
+declare function declareClass(id: Identifier, typeParameters: TypeParameterDeclaration | null | undefined, _extends: InterfaceExtends[] | null | undefined, body: ObjectTypeAnnotation): DeclareClass;
+declare function declareFunction(id: Identifier): DeclareFunction;
+declare function declareInterface(id: Identifier, typeParameters: TypeParameterDeclaration | null | undefined, _extends: InterfaceExtends[] | null | undefined, body: ObjectTypeAnnotation): DeclareInterface;
+declare function declareModule(id: Identifier | StringLiteral, body: BlockStatement, kind?: "CommonJS" | "ES" | null): DeclareModule;
+declare function declareModuleExports(typeAnnotation: TypeAnnotation): DeclareModuleExports;
+declare function declareTypeAlias(id: Identifier, typeParameters: TypeParameterDeclaration | null | undefined, right: FlowType): DeclareTypeAlias;
+declare function declareOpaqueType(id: Identifier, typeParameters?: TypeParameterDeclaration | null, supertype?: FlowType | null): DeclareOpaqueType;
+declare function declareVariable(id: Identifier): DeclareVariable;
+declare function declareExportDeclaration(declaration?: Flow | null, specifiers?: (ExportSpecifier | ExportNamespaceSpecifier)[] | null, source?: StringLiteral | null, attributes?: ImportAttribute[] | null): DeclareExportDeclaration;
+declare function declareExportAllDeclaration(source: StringLiteral, attributes?: ImportAttribute[] | null): DeclareExportAllDeclaration;
+declare function declaredPredicate(value: Flow): DeclaredPredicate;
+declare function existsTypeAnnotation(): ExistsTypeAnnotation;
+declare function functionTypeAnnotation(typeParameters: TypeParameterDeclaration | null | undefined, params: FunctionTypeParam[], rest: FunctionTypeParam | null | undefined, returnType: FlowType): FunctionTypeAnnotation;
+declare function functionTypeParam(name: Identifier | null | undefined, typeAnnotation: FlowType): FunctionTypeParam;
+declare function genericTypeAnnotation(id: Identifier | QualifiedTypeIdentifier, typeParameters?: TypeParameterInstantiation | null): GenericTypeAnnotation;
+declare function inferredPredicate(): InferredPredicate;
+declare function interfaceExtends(id: Identifier | QualifiedTypeIdentifier, typeParameters?: TypeParameterInstantiation | null): InterfaceExtends;
+declare function interfaceDeclaration(id: Identifier, typeParameters: TypeParameterDeclaration | null | undefined, _extends: InterfaceExtends[] | null | undefined, body: ObjectTypeAnnotation): InterfaceDeclaration;
+declare function interfaceTypeAnnotation(_extends: InterfaceExtends[] | null | undefined, body: ObjectTypeAnnotation): InterfaceTypeAnnotation;
+declare function intersectionTypeAnnotation(types: FlowType[]): IntersectionTypeAnnotation;
+declare function mixedTypeAnnotation(): MixedTypeAnnotation;
+declare function emptyTypeAnnotation(): EmptyTypeAnnotation;
+declare function nullableTypeAnnotation(typeAnnotation: FlowType): NullableTypeAnnotation;
+declare function numberLiteralTypeAnnotation(value: number): NumberLiteralTypeAnnotation;
+declare function numberTypeAnnotation(): NumberTypeAnnotation;
+declare function objectTypeAnnotation(properties: (ObjectTypeProperty | ObjectTypeSpreadProperty)[], indexers?: ObjectTypeIndexer[], callProperties?: ObjectTypeCallProperty[], internalSlots?: ObjectTypeInternalSlot[], exact?: boolean): ObjectTypeAnnotation;
+declare function objectTypeInternalSlot(id: Identifier, value: FlowType, optional: boolean, _static: boolean, method: boolean): ObjectTypeInternalSlot;
+declare function objectTypeCallProperty(value: FlowType): ObjectTypeCallProperty;
+declare function objectTypeIndexer(id: Identifier | null | undefined, key: FlowType, value: FlowType, variance?: Variance | null): ObjectTypeIndexer;
+declare function objectTypeProperty(key: Identifier | StringLiteral, value: FlowType, variance?: Variance | null): ObjectTypeProperty;
+declare function objectTypeSpreadProperty(argument: FlowType): ObjectTypeSpreadProperty;
+declare function opaqueType(id: Identifier, typeParameters: TypeParameterDeclaration | null | undefined, supertype: FlowType | null | undefined, impltype: FlowType): OpaqueType;
+declare function qualifiedTypeIdentifier(id: Identifier, qualification: Identifier | QualifiedTypeIdentifier): QualifiedTypeIdentifier;
+declare function stringLiteralTypeAnnotation(value: string): StringLiteralTypeAnnotation;
+declare function stringTypeAnnotation(): StringTypeAnnotation;
+declare function symbolTypeAnnotation(): SymbolTypeAnnotation;
+declare function thisTypeAnnotation(): ThisTypeAnnotation;
+declare function tupleTypeAnnotation(types: FlowType[]): TupleTypeAnnotation;
+declare function typeofTypeAnnotation(argument: FlowType): TypeofTypeAnnotation;
+declare function typeAlias(id: Identifier, typeParameters: TypeParameterDeclaration | null | undefined, right: FlowType): TypeAlias;
+declare function typeAnnotation(typeAnnotation: FlowType): TypeAnnotation;
+declare function typeCastExpression(expression: Expression, typeAnnotation: TypeAnnotation): TypeCastExpression;
+declare function typeParameter(bound?: TypeAnnotation | null, _default?: FlowType | null, variance?: Variance | null): TypeParameter;
+declare function typeParameterDeclaration(params: TypeParameter[]): TypeParameterDeclaration;
+declare function typeParameterInstantiation(params: FlowType[]): TypeParameterInstantiation;
+declare function unionTypeAnnotation(types: FlowType[]): UnionTypeAnnotation;
+declare function variance(kind: "minus" | "plus"): Variance;
+declare function voidTypeAnnotation(): VoidTypeAnnotation;
+declare function enumDeclaration(id: Identifier, body: EnumBooleanBody | EnumNumberBody | EnumStringBody | EnumSymbolBody): EnumDeclaration;
+declare function enumBooleanBody(members: EnumBooleanMember[]): EnumBooleanBody;
+declare function enumNumberBody(members: EnumNumberMember[]): EnumNumberBody;
+declare function enumStringBody(members: (EnumStringMember | EnumDefaultedMember)[]): EnumStringBody;
+declare function enumSymbolBody(members: EnumDefaultedMember[]): EnumSymbolBody;
+declare function enumBooleanMember(id: Identifier): EnumBooleanMember;
+declare function enumNumberMember(id: Identifier, init: NumericLiteral): EnumNumberMember;
+declare function enumStringMember(id: Identifier, init: StringLiteral): EnumStringMember;
+declare function enumDefaultedMember(id: Identifier): EnumDefaultedMember;
+declare function indexedAccessType(objectType: FlowType, indexType: FlowType): IndexedAccessType;
+declare function optionalIndexedAccessType(objectType: FlowType, indexType: FlowType): OptionalIndexedAccessType;
+declare function jsxAttribute(name: JSXIdentifier | JSXNamespacedName, value?: JSXElement | JSXFragment | StringLiteral | JSXExpressionContainer | null): JSXAttribute;
+declare function jsxClosingElement(name: JSXIdentifier | JSXMemberExpression | JSXNamespacedName): JSXClosingElement;
+declare function jsxElement(openingElement: JSXOpeningElement, closingElement: JSXClosingElement | null | undefined, children: (JSXText | JSXExpressionContainer | JSXSpreadChild | JSXElement | JSXFragment)[], selfClosing?: boolean | null): JSXElement;
+declare function jsxEmptyExpression(): JSXEmptyExpression;
+declare function jsxExpressionContainer(expression: Expression | JSXEmptyExpression): JSXExpressionContainer;
+declare function jsxSpreadChild(expression: Expression): JSXSpreadChild;
+declare function jsxIdentifier(name: string): JSXIdentifier;
+declare function jsxMemberExpression(object: JSXMemberExpression | JSXIdentifier, property: JSXIdentifier): JSXMemberExpression;
+declare function jsxNamespacedName(namespace: JSXIdentifier, name: JSXIdentifier): JSXNamespacedName;
+declare function jsxOpeningElement(name: JSXIdentifier | JSXMemberExpression | JSXNamespacedName, attributes: (JSXAttribute | JSXSpreadAttribute)[], selfClosing?: boolean): JSXOpeningElement;
+declare function jsxSpreadAttribute(argument: Expression): JSXSpreadAttribute;
+declare function jsxText(value: string): JSXText;
+declare function jsxFragment(openingFragment: JSXOpeningFragment, closingFragment: JSXClosingFragment, children: (JSXText | JSXExpressionContainer | JSXSpreadChild | JSXElement | JSXFragment)[]): JSXFragment;
+declare function jsxOpeningFragment(): JSXOpeningFragment;
+declare function jsxClosingFragment(): JSXClosingFragment;
+declare function noop(): Noop;
+declare function placeholder(expectedNode: "Identifier" | "StringLiteral" | "Expression" | "Statement" | "Declaration" | "BlockStatement" | "ClassBody" | "Pattern", name: Identifier): Placeholder;
+declare function v8IntrinsicIdentifier(name: string): V8IntrinsicIdentifier;
+declare function argumentPlaceholder(): ArgumentPlaceholder;
+declare function bindExpression(object: Expression, callee: Expression): BindExpression;
+declare function decorator(expression: Expression): Decorator;
+declare function doExpression(body: BlockStatement, async?: boolean): DoExpression;
+declare function exportDefaultSpecifier(exported: Identifier): ExportDefaultSpecifier;
+declare function recordExpression(properties: (ObjectProperty | SpreadElement)[]): RecordExpression;
+declare function tupleExpression(elements?: (Expression | SpreadElement)[]): TupleExpression;
+declare function decimalLiteral(value: string): DecimalLiteral;
+declare function moduleExpression(body: Program): ModuleExpression;
+declare function topicReference(): TopicReference;
+declare function pipelineTopicExpression(expression: Expression): PipelineTopicExpression;
+declare function pipelineBareFunction(callee: Expression): PipelineBareFunction;
+declare function pipelinePrimaryTopicReference(): PipelinePrimaryTopicReference;
+declare function voidPattern(): VoidPattern;
+declare function tsParameterProperty(parameter: Identifier | AssignmentPattern): TSParameterProperty;
+declare function tsDeclareFunction(id: Identifier | null | undefined, typeParameters: TSTypeParameterDeclaration | Noop | null | undefined, params: FunctionParameter[], returnType?: TSTypeAnnotation | Noop | null): TSDeclareFunction;
+declare function tsDeclareMethod(decorators: Decorator[] | null | undefined, key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | Expression, typeParameters: TSTypeParameterDeclaration | Noop | null | undefined, params: (FunctionParameter | TSParameterProperty)[], returnType?: TSTypeAnnotation | Noop | null): TSDeclareMethod;
+declare function tsQualifiedName(left: TSEntityName, right: Identifier): TSQualifiedName;
+declare function tsCallSignatureDeclaration(typeParameters: TSTypeParameterDeclaration | null | undefined, parameters: (ArrayPattern | Identifier | ObjectPattern | RestElement)[], typeAnnotation?: TSTypeAnnotation | null): TSCallSignatureDeclaration;
+declare function tsConstructSignatureDeclaration(typeParameters: TSTypeParameterDeclaration | null | undefined, parameters: (ArrayPattern | Identifier | ObjectPattern | RestElement)[], typeAnnotation?: TSTypeAnnotation | null): TSConstructSignatureDeclaration;
+declare function tsPropertySignature(key: Expression, typeAnnotation?: TSTypeAnnotation | null): TSPropertySignature;
+declare function tsMethodSignature(key: Expression, typeParameters: TSTypeParameterDeclaration | null | undefined, parameters: (ArrayPattern | Identifier | ObjectPattern | RestElement)[], typeAnnotation?: TSTypeAnnotation | null): TSMethodSignature;
+declare function tsIndexSignature(parameters: Identifier[], typeAnnotation?: TSTypeAnnotation | null): TSIndexSignature;
+declare function tsAnyKeyword(): TSAnyKeyword;
+declare function tsBooleanKeyword(): TSBooleanKeyword;
+declare function tsBigIntKeyword(): TSBigIntKeyword;
+declare function tsIntrinsicKeyword(): TSIntrinsicKeyword;
+declare function tsNeverKeyword(): TSNeverKeyword;
+declare function tsNullKeyword(): TSNullKeyword;
+declare function tsNumberKeyword(): TSNumberKeyword;
+declare function tsObjectKeyword(): TSObjectKeyword;
+declare function tsStringKeyword(): TSStringKeyword;
+declare function tsSymbolKeyword(): TSSymbolKeyword;
+declare function tsUndefinedKeyword(): TSUndefinedKeyword;
+declare function tsUnknownKeyword(): TSUnknownKeyword;
+declare function tsVoidKeyword(): TSVoidKeyword;
+declare function tsThisType(): TSThisType;
+declare function tsFunctionType(typeParameters: TSTypeParameterDeclaration | null | undefined, parameters: (ArrayPattern | Identifier | ObjectPattern | RestElement)[], typeAnnotation?: TSTypeAnnotation | null): TSFunctionType;
+declare function tsConstructorType(typeParameters: TSTypeParameterDeclaration | null | undefined, parameters: (ArrayPattern | Identifier | ObjectPattern | RestElement)[], typeAnnotation?: TSTypeAnnotation | null): TSConstructorType;
+declare function tsTypeReference(typeName: TSEntityName, typeParameters?: TSTypeParameterInstantiation | null): TSTypeReference;
+declare function tsTypePredicate(parameterName: Identifier | TSThisType, typeAnnotation?: TSTypeAnnotation | null, asserts?: boolean | null): TSTypePredicate;
+declare function tsTypeQuery(exprName: TSEntityName | TSImportType, typeParameters?: TSTypeParameterInstantiation | null): TSTypeQuery;
+declare function tsTypeLiteral(members: TSTypeElement[]): TSTypeLiteral;
+declare function tsArrayType(elementType: TSType): TSArrayType;
+declare function tsTupleType(elementTypes: (TSType | TSNamedTupleMember)[]): TSTupleType;
+declare function tsOptionalType(typeAnnotation: TSType): TSOptionalType;
+declare function tsRestType(typeAnnotation: TSType): TSRestType;
+declare function tsNamedTupleMember(label: Identifier, elementType: TSType, optional?: boolean): TSNamedTupleMember;
+declare function tsUnionType(types: TSType[]): TSUnionType;
+declare function tsIntersectionType(types: TSType[]): TSIntersectionType;
+declare function tsConditionalType(checkType: TSType, extendsType: TSType, trueType: TSType, falseType: TSType): TSConditionalType;
+declare function tsInferType(typeParameter: TSTypeParameter): TSInferType;
+declare function tsParenthesizedType(typeAnnotation: TSType): TSParenthesizedType;
+declare function tsTypeOperator(typeAnnotation: TSType, operator?: string): TSTypeOperator;
+declare function tsIndexedAccessType(objectType: TSType, indexType: TSType): TSIndexedAccessType;
+declare function tsMappedType(typeParameter: TSTypeParameter, typeAnnotation?: TSType | null, nameType?: TSType | null): TSMappedType;
+declare function tsTemplateLiteralType(quasis: TemplateElement[], types: TSType[]): TSTemplateLiteralType;
+declare function tsLiteralType(literal: NumericLiteral | StringLiteral | BooleanLiteral | BigIntLiteral | TemplateLiteral | UnaryExpression): TSLiteralType;
+declare function tsExpressionWithTypeArguments(expression: TSEntityName, typeParameters?: TSTypeParameterInstantiation | null): TSExpressionWithTypeArguments;
+declare function tsInterfaceDeclaration(id: Identifier, typeParameters: TSTypeParameterDeclaration | null | undefined, _extends: TSExpressionWithTypeArguments[] | null | undefined, body: TSInterfaceBody): TSInterfaceDeclaration;
+declare function tsInterfaceBody(body: TSTypeElement[]): TSInterfaceBody;
+declare function tsTypeAliasDeclaration(id: Identifier, typeParameters: TSTypeParameterDeclaration | null | undefined, typeAnnotation: TSType): TSTypeAliasDeclaration;
+declare function tsInstantiationExpression(expression: Expression, typeParameters?: TSTypeParameterInstantiation | null): TSInstantiationExpression;
+declare function tsAsExpression(expression: Expression, typeAnnotation: TSType): TSAsExpression;
+declare function tsSatisfiesExpression(expression: Expression, typeAnnotation: TSType): TSSatisfiesExpression;
+declare function tsTypeAssertion(typeAnnotation: TSType, expression: Expression): TSTypeAssertion;
+declare function tsEnumBody(members: TSEnumMember[]): TSEnumBody;
+declare function tsEnumDeclaration(id: Identifier, members: TSEnumMember[]): TSEnumDeclaration;
+declare function tsEnumMember(id: Identifier | StringLiteral, initializer?: Expression | null): TSEnumMember;
+declare function tsModuleDeclaration(id: Identifier | StringLiteral, body: TSModuleBlock | TSModuleDeclaration): TSModuleDeclaration;
+declare function tsModuleBlock(body: Statement[]): TSModuleBlock;
+declare function tsImportType(argument: StringLiteral, qualifier?: TSEntityName | null, typeParameters?: TSTypeParameterInstantiation | null): TSImportType;
+declare function tsImportEqualsDeclaration(id: Identifier, moduleReference: TSEntityName | TSExternalModuleReference): TSImportEqualsDeclaration;
+declare function tsExternalModuleReference(expression: StringLiteral): TSExternalModuleReference;
+declare function tsNonNullExpression(expression: Expression): TSNonNullExpression;
+declare function tsExportAssignment(expression: Expression): TSExportAssignment;
+declare function tsNamespaceExportDeclaration(id: Identifier): TSNamespaceExportDeclaration;
+declare function tsTypeAnnotation(typeAnnotation: TSType): TSTypeAnnotation;
+declare function tsTypeParameterInstantiation(params: TSType[]): TSTypeParameterInstantiation;
+declare function tsTypeParameterDeclaration(params: TSTypeParameter[]): TSTypeParameterDeclaration;
+declare function tsTypeParameter(constraint: TSType | null | undefined, _default: TSType | null | undefined, name: string): TSTypeParameter;
+declare function isAccessor(node: object | null | undefined, opts?: object | null): node is Accessor;
+declare function assertAccessor(node: object | null | undefined, opts?: object | null): void;
+declare function isAnyTypeAnnotation(node: object | null | undefined, opts?: object | null): node is AnyTypeAnnotation;
+declare function assertAnyTypeAnnotation(node: object | null | undefined, opts?: object | null): void;
+declare function isArgumentPlaceholder(node: object | null | undefined, opts?: object | null): node is ArgumentPlaceholder;
+declare function assertArgumentPlaceholder(node: object | null | undefined, opts?: object | null): void;
+declare function isArrayExpression(node: object | null | undefined, opts?: object | null): node is ArrayExpression;
+declare function assertArrayExpression(node: object | null | undefined, opts?: object | null): void;
+declare function isArrayPattern(node: object | null | undefined, opts?: object | null): node is ArrayPattern;
+declare function assertArrayPattern(node: object | null | undefined, opts?: object | null): void;
+declare function isArrayTypeAnnotation(node: object | null | undefined, opts?: object | null): node is ArrayTypeAnnotation;
+declare function assertArrayTypeAnnotation(node: object | null | undefined, opts?: object | null): void;
+declare function isArrowFunctionExpression(node: object | null | undefined, opts?: object | null): node is ArrowFunctionExpression;
+declare function assertArrowFunctionExpression(node: object | null | undefined, opts?: object | null): void;
+declare function isAssignmentExpression(node: object | null | undefined, opts?: object | null): node is AssignmentExpression;
+declare function assertAssignmentExpression(node: object | null | undefined, opts?: object | null): void;
+declare function isAssignmentPattern(node: object | null | undefined, opts?: object | null): node is AssignmentPattern;
+declare function assertAssignmentPattern(node: object | null | undefined, opts?: object | null): void;
+declare function isAwaitExpression(node: object | null | undefined, opts?: object | null): node is AwaitExpression;
+declare function assertAwaitExpression(node: object | null | undefined, opts?: object | null): void;
+declare function isBigIntLiteral(node: object | null | undefined, opts?: object | null): node is BigIntLiteral;
+declare function assertBigIntLiteral(node: object | null | undefined, opts?: object | null): void;
+declare function isBinary(node: object | null | undefined, opts?: object | null): node is Binary;
+declare function assertBinary(node: object | null | undefined, opts?: object | null): void;
+declare function isBinaryExpression(node: object | null | undefined, opts?: object | null): node is BinaryExpression;
+declare function assertBinaryExpression(node: object | null | undefined, opts?: object | null): void;
+declare function isBindExpression(node: object | null | undefined, opts?: object | null): node is BindExpression;
+declare function assertBindExpression(node: object | null | undefined, opts?: object | null): void;
+declare function isBlock(node: object | null | undefined, opts?: object | null): node is Block;
+declare function assertBlock(node: object | null | undefined, opts?: object | null): void;
+declare function isBlockParent(node: object | null | undefined, opts?: object | null): node is BlockParent;
+declare function assertBlockParent(node: object | null | undefined, opts?: object | null): void;
+declare function isBlockStatement(node: object | null | undefined, opts?: object | null): node is BlockStatement;
+declare function assertBlockStatement(node: object | null | undefined, opts?: object | null): void;
+declare function isBooleanLiteral(node: object | null | undefined, opts?: object | null): node is BooleanLiteral;
+declare function assertBooleanLiteral(node: object | null | undefined, opts?: object | null): void;
+declare function isBooleanLiteralTypeAnnotation(node: object | null | undefined, opts?: object | null): node is BooleanLiteralTypeAnnotation;
+declare function assertBooleanLiteralTypeAnnotation(node: object | null | undefined, opts?: object | null): void;
+declare function isBooleanTypeAnnotation(node: object | null | undefined, opts?: object | null): node is BooleanTypeAnnotation;
+declare function assertBooleanTypeAnnotation(node: object | null | undefined, opts?: object | null): void;
+declare function isBreakStatement(node: object | null | undefined, opts?: object | null): node is BreakStatement;
+declare function assertBreakStatement(node: object | null | undefined, opts?: object | null): void;
+declare function isCallExpression(node: object | null | undefined, opts?: object | null): node is CallExpression;
+declare function assertCallExpression(node: object | null | undefined, opts?: object | null): void;
+declare function isCatchClause(node: object | null | undefined, opts?: object | null): node is CatchClause;
+declare function assertCatchClause(node: object | null | undefined, opts?: object | null): void;
+declare function isClass(node: object | null | undefined, opts?: object | null): node is Class;
+declare function assertClass(node: object | null | undefined, opts?: object | null): void;
+declare function isClassAccessorProperty(node: object | null | undefined, opts?: object | null): node is ClassAccessorProperty;
+declare function assertClassAccessorProperty(node: object | null | undefined, opts?: object | null): void;
+declare function isClassBody(node: object | null | undefined, opts?: object | null): node is ClassBody;
+declare function assertClassBody(node: object | null | undefined, opts?: object | null): void;
+declare function isClassDeclaration(node: object | null | undefined, opts?: object | null): node is ClassDeclaration;
+declare function assertClassDeclaration(node: object | null | undefined, opts?: object | null): void;
+declare function isClassExpression(node: object | null | undefined, opts?: object | null): node is ClassExpression;
+declare function assertClassExpression(node: object | null | undefined, opts?: object | null): void;
+declare function isClassImplements(node: object | null | undefined, opts?: object | null): node is ClassImplements;
+declare function assertClassImplements(node: object | null | undefined, opts?: object | null): void;
+declare function isClassMethod(node: object | null | undefined, opts?: object | null): node is ClassMethod;
+declare function assertClassMethod(node: object | null | undefined, opts?: object | null): void;
+declare function isClassPrivateMethod(node: object | null | undefined, opts?: object | null): node is ClassPrivateMethod;
+declare function assertClassPrivateMethod(node: object | null | undefined, opts?: object | null): void;
+declare function isClassPrivateProperty(node: object | null | undefined, opts?: object | null): node is ClassPrivateProperty;
+declare function assertClassPrivateProperty(node: object | null | undefined, opts?: object | null): void;
+declare function isClassProperty(node: object | null | undefined, opts?: object | null): node is ClassProperty;
+declare function assertClassProperty(node: object | null | undefined, opts?: object | null): void;
+declare function isCompletionStatement(node: object | null | undefined, opts?: object | null): node is CompletionStatement;
+declare function assertCompletionStatement(node: object | null | undefined, opts?: object | null): void;
+declare function isConditional(node: object | null | undefined, opts?: object | null): node is Conditional;
+declare function assertConditional(node: object | null | undefined, opts?: object | null): void;
+declare function isConditionalExpression(node: object | null | undefined, opts?: object | null): node is ConditionalExpression;
+declare function assertConditionalExpression(node: object | null | undefined, opts?: object | null): void;
+declare function isContinueStatement(node: object | null | undefined, opts?: object | null): node is ContinueStatement;
+declare function assertContinueStatement(node: object | null | undefined, opts?: object | null): void;
+declare function isDebuggerStatement(node: object | null | undefined, opts?: object | null): node is DebuggerStatement;
+declare function assertDebuggerStatement(node: object | null | undefined, opts?: object | null): void;
+declare function isDecimalLiteral(node: object | null | undefined, opts?: object | null): node is DecimalLiteral;
+declare function assertDecimalLiteral(node: object | null | undefined, opts?: object | null): void;
+declare function isDeclaration(node: object | null | undefined, opts?: object | null): node is Declaration;
+declare function assertDeclaration(node: object | null | undefined, opts?: object | null): void;
+declare function isDeclareClass(node: object | null | undefined, opts?: object | null): node is DeclareClass;
+declare function assertDeclareClass(node: object | null | undefined, opts?: object | null): void;
+declare function isDeclareExportAllDeclaration(node: object | null | undefined, opts?: object | null): node is DeclareExportAllDeclaration;
+declare function assertDeclareExportAllDeclaration(node: object | null | undefined, opts?: object | null): void;
+declare function isDeclareExportDeclaration(node: object | null | undefined, opts?: object | null): node is DeclareExportDeclaration;
+declare function assertDeclareExportDeclaration(node: object | null | undefined, opts?: object | null): void;
+declare function isDeclareFunction(node: object | null | undefined, opts?: object | null): node is DeclareFunction;
+declare function assertDeclareFunction(node: object | null | undefined, opts?: object | null): void;
+declare function isDeclareInterface(node: object | null | undefined, opts?: object | null): node is DeclareInterface;
+declare function assertDeclareInterface(node: object | null | undefined, opts?: object | null): void;
+declare function isDeclareModule(node: object | null | undefined, opts?: object | null): node is DeclareModule;
+declare function assertDeclareModule(node: object | null | undefined, opts?: object | null): void;
+declare function isDeclareModuleExports(node: object | null | undefined, opts?: object | null): node is DeclareModuleExports;
+declare function assertDeclareModuleExports(node: object | null | undefined, opts?: object | null): void;
+declare function isDeclareOpaqueType(node: object | null | undefined, opts?: object | null): node is DeclareOpaqueType;
+declare function assertDeclareOpaqueType(node: object | null | undefined, opts?: object | null): void;
+declare function isDeclareTypeAlias(node: object | null | undefined, opts?: object | null): node is DeclareTypeAlias;
+declare function assertDeclareTypeAlias(node: object | null | undefined, opts?: object | null): void;
+declare function isDeclareVariable(node: object | null | undefined, opts?: object | null): node is DeclareVariable;
+declare function assertDeclareVariable(node: object | null | undefined, opts?: object | null): void;
+declare function isDeclaredPredicate(node: object | null | undefined, opts?: object | null): node is DeclaredPredicate;
+declare function assertDeclaredPredicate(node: object | null | undefined, opts?: object | null): void;
+declare function isDecorator(node: object | null | undefined, opts?: object | null): node is Decorator;
+declare function assertDecorator(node: object | null | undefined, opts?: object | null): void;
+declare function isDirective(node: object | null | undefined, opts?: object | null): node is Directive;
+declare function assertDirective(node: object | null | undefined, opts?: object | null): void;
+declare function isDirectiveLiteral(node: object | null | undefined, opts?: object | null): node is DirectiveLiteral;
+declare function assertDirectiveLiteral(node: object | null | undefined, opts?: object | null): void;
+declare function isDoExpression(node: object | null | undefined, opts?: object | null): node is DoExpression;
+declare function assertDoExpression(node: object | null | undefined, opts?: object | null): void;
+declare function isDoWhileStatement(node: object | null | undefined, opts?: object | null): node is DoWhileStatement;
+declare function assertDoWhileStatement(node: object | null | undefined, opts?: object | null): void;
+declare function isEmptyStatement(node: object | null | undefined, opts?: object | null): node is EmptyStatement;
+declare function assertEmptyStatement(node: object | null | undefined, opts?: object | null): void;
+declare function isEmptyTypeAnnotation(node: object | null | undefined, opts?: object | null): node is EmptyTypeAnnotation;
+declare function assertEmptyTypeAnnotation(node: object | null | undefined, opts?: object | null): void;
+declare function isEnumBody(node: object | null | undefined, opts?: object | null): node is EnumBody;
+declare function assertEnumBody(node: object | null | undefined, opts?: object | null): void;
+declare function isEnumBooleanBody(node: object | null | undefined, opts?: object | null): node is EnumBooleanBody;
+declare function assertEnumBooleanBody(node: object | null | undefined, opts?: object | null): void;
+declare function isEnumBooleanMember(node: object | null | undefined, opts?: object | null): node is EnumBooleanMember;
+declare function assertEnumBooleanMember(node: object | null | undefined, opts?: object | null): void;
+declare function isEnumDeclaration(node: object | null | undefined, opts?: object | null): node is EnumDeclaration;
+declare function assertEnumDeclaration(node: object | null | undefined, opts?: object | null): void;
+declare function isEnumDefaultedMember(node: object | null | undefined, opts?: object | null): node is EnumDefaultedMember;
+declare function assertEnumDefaultedMember(node: object | null | undefined, opts?: object | null): void;
+declare function isEnumMember(node: object | null | undefined, opts?: object | null): node is EnumMember;
+declare function assertEnumMember(node: object | null | undefined, opts?: object | null): void;
+declare function isEnumNumberBody(node: object | null | undefined, opts?: object | null): node is EnumNumberBody;
+declare function assertEnumNumberBody(node: object | null | undefined, opts?: object | null): void;
+declare function isEnumNumberMember(node: object | null | undefined, opts?: object | null): node is EnumNumberMember;
+declare function assertEnumNumberMember(node: object | null | undefined, opts?: object | null): void;
+declare function isEnumStringBody(node: object | null | undefined, opts?: object | null): node is EnumStringBody;
+declare function assertEnumStringBody(node: object | null | undefined, opts?: object | null): void;
+declare function isEnumStringMember(node: object | null | undefined, opts?: object | null): node is EnumStringMember;
+declare function assertEnumStringMember(node: object | null | undefined, opts?: object | null): void;
+declare function isEnumSymbolBody(node: object | null | undefined, opts?: object | null): node is EnumSymbolBody;
+declare function assertEnumSymbolBody(node: object | null | undefined, opts?: object | null): void;
+declare function isExistsTypeAnnotation(node: object | null | undefined, opts?: object | null): node is ExistsTypeAnnotation;
+declare function assertExistsTypeAnnotation(node: object | null | undefined, opts?: object | null): void;
+declare function isExportAllDeclaration(node: object | null | undefined, opts?: object | null): node is ExportAllDeclaration;
+declare function assertExportAllDeclaration(node: object | null | undefined, opts?: object | null): void;
+declare function isExportDeclaration(node: object | null | undefined, opts?: object | null): node is ExportDeclaration;
+declare function assertExportDeclaration(node: object | null | undefined, opts?: object | null): void;
+declare function isExportDefaultDeclaration(node: object | null | undefined, opts?: object | null): node is ExportDefaultDeclaration;
+declare function assertExportDefaultDeclaration(node: object | null | undefined, opts?: object | null): void;
+declare function isExportDefaultSpecifier(node: object | null | undefined, opts?: object | null): node is ExportDefaultSpecifier;
+declare function assertExportDefaultSpecifier(node: object | null | undefined, opts?: object | null): void;
+declare function isExportNamedDeclaration(node: object | null | undefined, opts?: object | null): node is ExportNamedDeclaration;
+declare function assertExportNamedDeclaration(node: object | null | undefined, opts?: object | null): void;
+declare function isExportNamespaceSpecifier(node: object | null | undefined, opts?: object | null): node is ExportNamespaceSpecifier;
+declare function assertExportNamespaceSpecifier(node: object | null | undefined, opts?: object | null): void;
+declare function isExportSpecifier(node: object | null | undefined, opts?: object | null): node is ExportSpecifier;
+declare function assertExportSpecifier(node: object | null | undefined, opts?: object | null): void;
+declare function isExpression(node: object | null | undefined, opts?: object | null): node is Expression;
+declare function assertExpression(node: object | null | undefined, opts?: object | null): void;
+declare function isExpressionStatement(node: object | null | undefined, opts?: object | null): node is ExpressionStatement;
+declare function assertExpressionStatement(node: object | null | undefined, opts?: object | null): void;
+declare function isExpressionWrapper(node: object | null | undefined, opts?: object | null): node is ExpressionWrapper;
+declare function assertExpressionWrapper(node: object | null | undefined, opts?: object | null): void;
+declare function isFile(node: object | null | undefined, opts?: object | null): node is File;
+declare function assertFile(node: object | null | undefined, opts?: object | null): void;
+declare function isFlow(node: object | null | undefined, opts?: object | null): node is Flow;
+declare function assertFlow(node: object | null | undefined, opts?: object | null): void;
+declare function isFlowBaseAnnotation(node: object | null | undefined, opts?: object | null): node is FlowBaseAnnotation;
+declare function assertFlowBaseAnnotation(node: object | null | undefined, opts?: object | null): void;
+declare function isFlowDeclaration(node: object | null | undefined, opts?: object | null): node is FlowDeclaration;
+declare function assertFlowDeclaration(node: object | null | undefined, opts?: object | null): void;
+declare function isFlowPredicate(node: object | null | undefined, opts?: object | null): node is FlowPredicate;
+declare function assertFlowPredicate(node: object | null | undefined, opts?: object | null): void;
+declare function isFlowType(node: object | null | undefined, opts?: object | null): node is FlowType;
+declare function assertFlowType(node: object | null | undefined, opts?: object | null): void;
+declare function isFor(node: object | null | undefined, opts?: object | null): node is For;
+declare function assertFor(node: object | null | undefined, opts?: object | null): void;
+declare function isForInStatement(node: object | null | undefined, opts?: object | null): node is ForInStatement;
+declare function assertForInStatement(node: object | null | undefined, opts?: object | null): void;
+declare function isForOfStatement(node: object | null | undefined, opts?: object | null): node is ForOfStatement;
+declare function assertForOfStatement(node: object | null | undefined, opts?: object | null): void;
+declare function isForStatement(node: object | null | undefined, opts?: object | null): node is ForStatement;
+declare function assertForStatement(node: object | null | undefined, opts?: object | null): void;
+declare function isForXStatement(node: object | null | undefined, opts?: object | null): node is ForXStatement;
+declare function assertForXStatement(node: object | null | undefined, opts?: object | null): void;
+declare function isFunction(node: object | null | undefined, opts?: object | null): node is Function;
+declare function assertFunction(node: object | null | undefined, opts?: object | null): void;
+declare function isFunctionDeclaration(node: object | null | undefined, opts?: object | null): node is FunctionDeclaration;
+declare function assertFunctionDeclaration(node: object | null | undefined, opts?: object | null): void;
+declare function isFunctionExpression(node: object | null | undefined, opts?: object | null): node is FunctionExpression;
+declare function assertFunctionExpression(node: object | null | undefined, opts?: object | null): void;
+declare function isFunctionParameter(node: object | null | undefined, opts?: object | null): node is FunctionParameter;
+declare function assertFunctionParameter(node: object | null | undefined, opts?: object | null): void;
+declare function isFunctionParent(node: object | null | undefined, opts?: object | null): node is FunctionParent;
+declare function assertFunctionParent(node: object | null | undefined, opts?: object | null): void;
+declare function isFunctionTypeAnnotation(node: object | null | undefined, opts?: object | null): node is FunctionTypeAnnotation;
+declare function assertFunctionTypeAnnotation(node: object | null | undefined, opts?: object | null): void;
+declare function isFunctionTypeParam(node: object | null | undefined, opts?: object | null): node is FunctionTypeParam;
+declare function assertFunctionTypeParam(node: object | null | undefined, opts?: object | null): void;
+declare function isGenericTypeAnnotation(node: object | null | undefined, opts?: object | null): node is GenericTypeAnnotation;
+declare function assertGenericTypeAnnotation(node: object | null | undefined, opts?: object | null): void;
+declare function isIdentifier(node: object | null | undefined, opts?: object | null): node is Identifier;
+declare function assertIdentifier(node: object | null | undefined, opts?: object | null): void;
+declare function isIfStatement(node: object | null | undefined, opts?: object | null): node is IfStatement;
+declare function assertIfStatement(node: object | null | undefined, opts?: object | null): void;
+declare function isImmutable(node: object | null | undefined, opts?: object | null): node is Immutable;
+declare function assertImmutable(node: object | null | undefined, opts?: object | null): void;
+declare function isImport(node: object | null | undefined, opts?: object | null): node is Import;
+declare function assertImport(node: object | null | undefined, opts?: object | null): void;
+declare function isImportAttribute(node: object | null | undefined, opts?: object | null): node is ImportAttribute;
+declare function assertImportAttribute(node: object | null | undefined, opts?: object | null): void;
+declare function isImportDeclaration(node: object | null | undefined, opts?: object | null): node is ImportDeclaration;
+declare function assertImportDeclaration(node: object | null | undefined, opts?: object | null): void;
+declare function isImportDefaultSpecifier(node: object | null | undefined, opts?: object | null): node is ImportDefaultSpecifier;
+declare function assertImportDefaultSpecifier(node: object | null | undefined, opts?: object | null): void;
+declare function isImportExpression(node: object | null | undefined, opts?: object | null): node is ImportExpression;
+declare function assertImportExpression(node: object | null | undefined, opts?: object | null): void;
+declare function isImportNamespaceSpecifier(node: object | null | undefined, opts?: object | null): node is ImportNamespaceSpecifier;
+declare function assertImportNamespaceSpecifier(node: object | null | undefined, opts?: object | null): void;
+declare function isImportOrExportDeclaration(node: object | null | undefined, opts?: object | null): node is ImportOrExportDeclaration;
+declare function assertImportOrExportDeclaration(node: object | null | undefined, opts?: object | null): void;
+declare function isImportSpecifier(node: object | null | undefined, opts?: object | null): node is ImportSpecifier;
+declare function assertImportSpecifier(node: object | null | undefined, opts?: object | null): void;
+declare function isIndexedAccessType(node: object | null | undefined, opts?: object | null): node is IndexedAccessType;
+declare function assertIndexedAccessType(node: object | null | undefined, opts?: object | null): void;
+declare function isInferredPredicate(node: object | null | undefined, opts?: object | null): node is InferredPredicate;
+declare function assertInferredPredicate(node: object | null | undefined, opts?: object | null): void;
+declare function isInterfaceDeclaration(node: object | null | undefined, opts?: object | null): node is InterfaceDeclaration;
+declare function assertInterfaceDeclaration(node: object | null | undefined, opts?: object | null): void;
+declare function isInterfaceExtends(node: object | null | undefined, opts?: object | null): node is InterfaceExtends;
+declare function assertInterfaceExtends(node: object | null | undefined, opts?: object | null): void;
+declare function isInterfaceTypeAnnotation(node: object | null | undefined, opts?: object | null): node is InterfaceTypeAnnotation;
+declare function assertInterfaceTypeAnnotation(node: object | null | undefined, opts?: object | null): void;
+declare function isInterpreterDirective(node: object | null | undefined, opts?: object | null): node is InterpreterDirective;
+declare function assertInterpreterDirective(node: object | null | undefined, opts?: object | null): void;
+declare function isIntersectionTypeAnnotation(node: object | null | undefined, opts?: object | null): node is IntersectionTypeAnnotation;
+declare function assertIntersectionTypeAnnotation(node: object | null | undefined, opts?: object | null): void;
+declare function isJSX(node: object | null | undefined, opts?: object | null): node is JSX;
+declare function assertJSX(node: object | null | undefined, opts?: object | null): void;
+declare function isJSXAttribute(node: object | null | undefined, opts?: object | null): node is JSXAttribute;
+declare function assertJSXAttribute(node: object | null | undefined, opts?: object | null): void;
+declare function isJSXClosingElement(node: object | null | undefined, opts?: object | null): node is JSXClosingElement;
+declare function assertJSXClosingElement(node: object | null | undefined, opts?: object | null): void;
+declare function isJSXClosingFragment(node: object | null | undefined, opts?: object | null): node is JSXClosingFragment;
+declare function assertJSXClosingFragment(node: object | null | undefined, opts?: object | null): void;
+declare function isJSXElement(node: object | null | undefined, opts?: object | null): node is JSXElement;
+declare function assertJSXElement(node: object | null | undefined, opts?: object | null): void;
+declare function isJSXEmptyExpression(node: object | null | undefined, opts?: object | null): node is JSXEmptyExpression;
+declare function assertJSXEmptyExpression(node: object | null | undefined, opts?: object | null): void;
+declare function isJSXExpressionContainer(node: object | null | undefined, opts?: object | null): node is JSXExpressionContainer;
+declare function assertJSXExpressionContainer(node: object | null | undefined, opts?: object | null): void;
+declare function isJSXFragment(node: object | null | undefined, opts?: object | null): node is JSXFragment;
+declare function assertJSXFragment(node: object | null | undefined, opts?: object | null): void;
+declare function isJSXIdentifier(node: object | null | undefined, opts?: object | null): node is JSXIdentifier;
+declare function assertJSXIdentifier(node: object | null | undefined, opts?: object | null): void;
+declare function isJSXMemberExpression(node: object | null | undefined, opts?: object | null): node is JSXMemberExpression;
+declare function assertJSXMemberExpression(node: object | null | undefined, opts?: object | null): void;
+declare function isJSXNamespacedName(node: object | null | undefined, opts?: object | null): node is JSXNamespacedName;
+declare function assertJSXNamespacedName(node: object | null | undefined, opts?: object | null): void;
+declare function isJSXOpeningElement(node: object | null | undefined, opts?: object | null): node is JSXOpeningElement;
+declare function assertJSXOpeningElement(node: object | null | undefined, opts?: object | null): void;
+declare function isJSXOpeningFragment(node: object | null | undefined, opts?: object | null): node is JSXOpeningFragment;
+declare function assertJSXOpeningFragment(node: object | null | undefined, opts?: object | null): void;
+declare function isJSXSpreadAttribute(node: object | null | undefined, opts?: object | null): node is JSXSpreadAttribute;
+declare function assertJSXSpreadAttribute(node: object | null | undefined, opts?: object | null): void;
+declare function isJSXSpreadChild(node: object | null | undefined, opts?: object | null): node is JSXSpreadChild;
+declare function assertJSXSpreadChild(node: object | null | undefined, opts?: object | null): void;
+declare function isJSXText(node: object | null | undefined, opts?: object | null): node is JSXText;
+declare function assertJSXText(node: object | null | undefined, opts?: object | null): void;
+declare function isLVal(node: object | null | undefined, opts?: object | null): node is LVal;
+declare function assertLVal(node: object | null | undefined, opts?: object | null): void;
+declare function isLabeledStatement(node: object | null | undefined, opts?: object | null): node is LabeledStatement;
+declare function assertLabeledStatement(node: object | null | undefined, opts?: object | null): void;
+declare function isLiteral(node: object | null | undefined, opts?: object | null): node is Literal;
+declare function assertLiteral(node: object | null | undefined, opts?: object | null): void;
+declare function isLogicalExpression(node: object | null | undefined, opts?: object | null): node is LogicalExpression;
+declare function assertLogicalExpression(node: object | null | undefined, opts?: object | null): void;
+declare function isLoop(node: object | null | undefined, opts?: object | null): node is Loop;
+declare function assertLoop(node: object | null | undefined, opts?: object | null): void;
+declare function isMemberExpression(node: object | null | undefined, opts?: object | null): node is MemberExpression;
+declare function assertMemberExpression(node: object | null | undefined, opts?: object | null): void;
+declare function isMetaProperty(node: object | null | undefined, opts?: object | null): node is MetaProperty;
+declare function assertMetaProperty(node: object | null | undefined, opts?: object | null): void;
+declare function isMethod(node: object | null | undefined, opts?: object | null): node is Method;
+declare function assertMethod(node: object | null | undefined, opts?: object | null): void;
+declare function isMiscellaneous(node: object | null | undefined, opts?: object | null): node is Miscellaneous;
+declare function assertMiscellaneous(node: object | null | undefined, opts?: object | null): void;
+declare function isMixedTypeAnnotation(node: object | null | undefined, opts?: object | null): node is MixedTypeAnnotation;
+declare function assertMixedTypeAnnotation(node: object | null | undefined, opts?: object | null): void;
+declare function isModuleDeclaration(node: object | null | undefined, opts?: object | null): node is ModuleDeclaration;
+declare function assertModuleDeclaration(node: object | null | undefined, opts?: object | null): void;
+declare function isModuleExpression(node: object | null | undefined, opts?: object | null): node is ModuleExpression;
+declare function assertModuleExpression(node: object | null | undefined, opts?: object | null): void;
+declare function isModuleSpecifier(node: object | null | undefined, opts?: object | null): node is ModuleSpecifier;
+declare function assertModuleSpecifier(node: object | null | undefined, opts?: object | null): void;
+declare function isNewExpression(node: object | null | undefined, opts?: object | null): node is NewExpression;
+declare function assertNewExpression(node: object | null | undefined, opts?: object | null): void;
+declare function isNoop(node: object | null | undefined, opts?: object | null): node is Noop;
+declare function assertNoop(node: object | null | undefined, opts?: object | null): void;
+declare function isNullLiteral(node: object | null | undefined, opts?: object | null): node is NullLiteral;
+declare function assertNullLiteral(node: object | null | undefined, opts?: object | null): void;
+declare function isNullLiteralTypeAnnotation(node: object | null | undefined, opts?: object | null): node is NullLiteralTypeAnnotation;
+declare function assertNullLiteralTypeAnnotation(node: object | null | undefined, opts?: object | null): void;
+declare function isNullableTypeAnnotation(node: object | null | undefined, opts?: object | null): node is NullableTypeAnnotation;
+declare function assertNullableTypeAnnotation(node: object | null | undefined, opts?: object | null): void;
+/** @deprecated Use `isNumericLiteral` */
+declare function isNumberLiteral(node: object | null | undefined, opts?: object | null): node is NumericLiteral;
+/** @deprecated Use `assertNumericLiteral` */
+declare function assertNumberLiteral(node: object | null | undefined, opts?: object | null): void;
+declare function isNumberLiteralTypeAnnotation(node: object | null | undefined, opts?: object | null): node is NumberLiteralTypeAnnotation;
+declare function assertNumberLiteralTypeAnnotation(node: object | null | undefined, opts?: object | null): void;
+declare function isNumberTypeAnnotation(node: object | null | undefined, opts?: object | null): node is NumberTypeAnnotation;
+declare function assertNumberTypeAnnotation(node: object | null | undefined, opts?: object | null): void;
+declare function isNumericLiteral(node: object | null | undefined, opts?: object | null): node is NumericLiteral;
+declare function assertNumericLiteral(node: object | null | undefined, opts?: object | null): void;
+declare function isObjectExpression(node: object | null | undefined, opts?: object | null): node is ObjectExpression;
+declare function assertObjectExpression(node: object | null | undefined, opts?: object | null): void;
+declare function isObjectMember(node: object | null | undefined, opts?: object | null): node is ObjectMember;
+declare function assertObjectMember(node: object | null | undefined, opts?: object | null): void;
+declare function isObjectMethod(node: object | null | undefined, opts?: object | null): node is ObjectMethod;
+declare function assertObjectMethod(node: object | null | undefined, opts?: object | null): void;
+declare function isObjectPattern(node: object | null | undefined, opts?: object | null): node is ObjectPattern;
+declare function assertObjectPattern(node: object | null | undefined, opts?: object | null): void;
+declare function isObjectProperty(node: object | null | undefined, opts?: object | null): node is ObjectProperty;
+declare function assertObjectProperty(node: object | null | undefined, opts?: object | null): void;
+declare function isObjectTypeAnnotation(node: object | null | undefined, opts?: object | null): node is ObjectTypeAnnotation;
+declare function assertObjectTypeAnnotation(node: object | null | undefined, opts?: object | null): void;
+declare function isObjectTypeCallProperty(node: object | null | undefined, opts?: object | null): node is ObjectTypeCallProperty;
+declare function assertObjectTypeCallProperty(node: object | null | undefined, opts?: object | null): void;
+declare function isObjectTypeIndexer(node: object | null | undefined, opts?: object | null): node is ObjectTypeIndexer;
+declare function assertObjectTypeIndexer(node: object | null | undefined, opts?: object | null): void;
+declare function isObjectTypeInternalSlot(node: object | null | undefined, opts?: object | null): node is ObjectTypeInternalSlot;
+declare function assertObjectTypeInternalSlot(node: object | null | undefined, opts?: object | null): void;
+declare function isObjectTypeProperty(node: object | null | undefined, opts?: object | null): node is ObjectTypeProperty;
+declare function assertObjectTypeProperty(node: object | null | undefined, opts?: object | null): void;
+declare function isObjectTypeSpreadProperty(node: object | null | undefined, opts?: object | null): node is ObjectTypeSpreadProperty;
+declare function assertObjectTypeSpreadProperty(node: object | null | undefined, opts?: object | null): void;
+declare function isOpaqueType(node: object | null | undefined, opts?: object | null): node is OpaqueType;
+declare function assertOpaqueType(node: object | null | undefined, opts?: object | null): void;
+declare function isOptionalCallExpression(node: object | null | undefined, opts?: object | null): node is OptionalCallExpression;
+declare function assertOptionalCallExpression(node: object | null | undefined, opts?: object | null): void;
+declare function isOptionalIndexedAccessType(node: object | null | undefined, opts?: object | null): node is OptionalIndexedAccessType;
+declare function assertOptionalIndexedAccessType(node: object | null | undefined, opts?: object | null): void;
+declare function isOptionalMemberExpression(node: object | null | undefined, opts?: object | null): node is OptionalMemberExpression;
+declare function assertOptionalMemberExpression(node: object | null | undefined, opts?: object | null): void;
+declare function isParenthesizedExpression(node: object | null | undefined, opts?: object | null): node is ParenthesizedExpression;
+declare function assertParenthesizedExpression(node: object | null | undefined, opts?: object | null): void;
+declare function isPattern(node: object | null | undefined, opts?: object | null): node is Pattern;
+declare function assertPattern(node: object | null | undefined, opts?: object | null): void;
+declare function isPatternLike(node: object | null | undefined, opts?: object | null): node is PatternLike;
+declare function assertPatternLike(node: object | null | undefined, opts?: object | null): void;
+declare function isPipelineBareFunction(node: object | null | undefined, opts?: object | null): node is PipelineBareFunction;
+declare function assertPipelineBareFunction(node: object | null | undefined, opts?: object | null): void;
+declare function isPipelinePrimaryTopicReference(node: object | null | undefined, opts?: object | null): node is PipelinePrimaryTopicReference;
+declare function assertPipelinePrimaryTopicReference(node: object | null | undefined, opts?: object | null): void;
+declare function isPipelineTopicExpression(node: object | null | undefined, opts?: object | null): node is PipelineTopicExpression;
+declare function assertPipelineTopicExpression(node: object | null | undefined, opts?: object | null): void;
+declare function isPlaceholder(node: object | null | undefined, opts?: object | null): node is Placeholder;
+declare function assertPlaceholder(node: object | null | undefined, opts?: object | null): void;
+declare function isPrivate(node: object | null | undefined, opts?: object | null): node is Private;
+declare function assertPrivate(node: object | null | undefined, opts?: object | null): void;
+declare function isPrivateName(node: object | null | undefined, opts?: object | null): node is PrivateName;
+declare function assertPrivateName(node: object | null | undefined, opts?: object | null): void;
+declare function isProgram(node: object | null | undefined, opts?: object | null): node is Program;
+declare function assertProgram(node: object | null | undefined, opts?: object | null): void;
+declare function isProperty(node: object | null | undefined, opts?: object | null): node is Property;
+declare function assertProperty(node: object | null | undefined, opts?: object | null): void;
+declare function isPureish(node: object | null | undefined, opts?: object | null): node is Pureish;
+declare function assertPureish(node: object | null | undefined, opts?: object | null): void;
+declare function isQualifiedTypeIdentifier(node: object | null | undefined, opts?: object | null): node is QualifiedTypeIdentifier;
+declare function assertQualifiedTypeIdentifier(node: object | null | undefined, opts?: object | null): void;
+declare function isRecordExpression(node: object | null | undefined, opts?: object | null): node is RecordExpression;
+declare function assertRecordExpression(node: object | null | undefined, opts?: object | null): void;
+declare function isRegExpLiteral(node: object | null | undefined, opts?: object | null): node is RegExpLiteral;
+declare function assertRegExpLiteral(node: object | null | undefined, opts?: object | null): void;
+/** @deprecated Use `isRegExpLiteral` */
+declare function isRegexLiteral(node: object | null | undefined, opts?: object | null): node is RegExpLiteral;
+/** @deprecated Use `assertRegExpLiteral` */
+declare function assertRegexLiteral(node: object | null | undefined, opts?: object | null): void;
+declare function isRestElement(node: object | null | undefined, opts?: object | null): node is RestElement;
+declare function assertRestElement(node: object | null | undefined, opts?: object | null): void;
+/** @deprecated Use `isRestElement` */
+declare function isRestProperty(node: object | null | undefined, opts?: object | null): node is RestElement;
+/** @deprecated Use `assertRestElement` */
+declare function assertRestProperty(node: object | null | undefined, opts?: object | null): void;
+declare function isReturnStatement(node: object | null | undefined, opts?: object | null): node is ReturnStatement;
+declare function assertReturnStatement(node: object | null | undefined, opts?: object | null): void;
+declare function isScopable(node: object | null | undefined, opts?: object | null): node is Scopable;
+declare function assertScopable(node: object | null | undefined, opts?: object | null): void;
+declare function isSequenceExpression(node: object | null | undefined, opts?: object | null): node is SequenceExpression;
+declare function assertSequenceExpression(node: object | null | undefined, opts?: object | null): void;
+declare function isSpreadElement(node: object | null | undefined, opts?: object | null): node is SpreadElement;
+declare function assertSpreadElement(node: object | null | undefined, opts?: object | null): void;
+/** @deprecated Use `isSpreadElement` */
+declare function isSpreadProperty(node: object | null | undefined, opts?: object | null): node is SpreadElement;
+/** @deprecated Use `assertSpreadElement` */
+declare function assertSpreadProperty(node: object | null | undefined, opts?: object | null): void;
+declare function isStandardized(node: object | null | undefined, opts?: object | null): node is Standardized;
+declare function assertStandardized(node: object | null | undefined, opts?: object | null): void;
+declare function isStatement(node: object | null | undefined, opts?: object | null): node is Statement;
+declare function assertStatement(node: object | null | undefined, opts?: object | null): void;
+declare function isStaticBlock(node: object | null | undefined, opts?: object | null): node is StaticBlock;
+declare function assertStaticBlock(node: object | null | undefined, opts?: object | null): void;
+declare function isStringLiteral(node: object | null | undefined, opts?: object | null): node is StringLiteral;
+declare function assertStringLiteral(node: object | null | undefined, opts?: object | null): void;
+declare function isStringLiteralTypeAnnotation(node: object | null | undefined, opts?: object | null): node is StringLiteralTypeAnnotation;
+declare function assertStringLiteralTypeAnnotation(node: object | null | undefined, opts?: object | null): void;
+declare function isStringTypeAnnotation(node: object | null | undefined, opts?: object | null): node is StringTypeAnnotation;
+declare function assertStringTypeAnnotation(node: object | null | undefined, opts?: object | null): void;
+declare function isSuper(node: object | null | undefined, opts?: object | null): node is Super;
+declare function assertSuper(node: object | null | undefined, opts?: object | null): void;
+declare function isSwitchCase(node: object | null | undefined, opts?: object | null): node is SwitchCase;
+declare function assertSwitchCase(node: object | null | undefined, opts?: object | null): void;
+declare function isSwitchStatement(node: object | null | undefined, opts?: object | null): node is SwitchStatement;
+declare function assertSwitchStatement(node: object | null | undefined, opts?: object | null): void;
+declare function isSymbolTypeAnnotation(node: object | null | undefined, opts?: object | null): node is SymbolTypeAnnotation;
+declare function assertSymbolTypeAnnotation(node: object | null | undefined, opts?: object | null): void;
+declare function isTSAnyKeyword(node: object | null | undefined, opts?: object | null): node is TSAnyKeyword;
+declare function assertTSAnyKeyword(node: object | null | undefined, opts?: object | null): void;
+declare function isTSArrayType(node: object | null | undefined, opts?: object | null): node is TSArrayType;
+declare function assertTSArrayType(node: object | null | undefined, opts?: object | null): void;
+declare function isTSAsExpression(node: object | null | undefined, opts?: object | null): node is TSAsExpression;
+declare function assertTSAsExpression(node: object | null | undefined, opts?: object | null): void;
+declare function isTSBaseType(node: object | null | undefined, opts?: object | null): node is TSBaseType;
+declare function assertTSBaseType(node: object | null | undefined, opts?: object | null): void;
+declare function isTSBigIntKeyword(node: object | null | undefined, opts?: object | null): node is TSBigIntKeyword;
+declare function assertTSBigIntKeyword(node: object | null | undefined, opts?: object | null): void;
+declare function isTSBooleanKeyword(node: object | null | undefined, opts?: object | null): node is TSBooleanKeyword;
+declare function assertTSBooleanKeyword(node: object | null | undefined, opts?: object | null): void;
+declare function isTSCallSignatureDeclaration(node: object | null | undefined, opts?: object | null): node is TSCallSignatureDeclaration;
+declare function assertTSCallSignatureDeclaration(node: object | null | undefined, opts?: object | null): void;
+declare function isTSConditionalType(node: object | null | undefined, opts?: object | null): node is TSConditionalType;
+declare function assertTSConditionalType(node: object | null | undefined, opts?: object | null): void;
+declare function isTSConstructSignatureDeclaration(node: object | null | undefined, opts?: object | null): node is TSConstructSignatureDeclaration;
+declare function assertTSConstructSignatureDeclaration(node: object | null | undefined, opts?: object | null): void;
+declare function isTSConstructorType(node: object | null | undefined, opts?: object | null): node is TSConstructorType;
+declare function assertTSConstructorType(node: object | null | undefined, opts?: object | null): void;
+declare function isTSDeclareFunction(node: object | null | undefined, opts?: object | null): node is TSDeclareFunction;
+declare function assertTSDeclareFunction(node: object | null | undefined, opts?: object | null): void;
+declare function isTSDeclareMethod(node: object | null | undefined, opts?: object | null): node is TSDeclareMethod;
+declare function assertTSDeclareMethod(node: object | null | undefined, opts?: object | null): void;
+declare function isTSEntityName(node: object | null | undefined, opts?: object | null): node is TSEntityName;
+declare function assertTSEntityName(node: object | null | undefined, opts?: object | null): void;
+declare function isTSEnumBody(node: object | null | undefined, opts?: object | null): node is TSEnumBody;
+declare function assertTSEnumBody(node: object | null | undefined, opts?: object | null): void;
+declare function isTSEnumDeclaration(node: object | null | undefined, opts?: object | null): node is TSEnumDeclaration;
+declare function assertTSEnumDeclaration(node: object | null | undefined, opts?: object | null): void;
+declare function isTSEnumMember(node: object | null | undefined, opts?: object | null): node is TSEnumMember;
+declare function assertTSEnumMember(node: object | null | undefined, opts?: object | null): void;
+declare function isTSExportAssignment(node: object | null | undefined, opts?: object | null): node is TSExportAssignment;
+declare function assertTSExportAssignment(node: object | null | undefined, opts?: object | null): void;
+declare function isTSExpressionWithTypeArguments(node: object | null | undefined, opts?: object | null): node is TSExpressionWithTypeArguments;
+declare function assertTSExpressionWithTypeArguments(node: object | null | undefined, opts?: object | null): void;
+declare function isTSExternalModuleReference(node: object | null | undefined, opts?: object | null): node is TSExternalModuleReference;
+declare function assertTSExternalModuleReference(node: object | null | undefined, opts?: object | null): void;
+declare function isTSFunctionType(node: object | null | undefined, opts?: object | null): node is TSFunctionType;
+declare function assertTSFunctionType(node: object | null | undefined, opts?: object | null): void;
+declare function isTSImportEqualsDeclaration(node: object | null | undefined, opts?: object | null): node is TSImportEqualsDeclaration;
+declare function assertTSImportEqualsDeclaration(node: object | null | undefined, opts?: object | null): void;
+declare function isTSImportType(node: object | null | undefined, opts?: object | null): node is TSImportType;
+declare function assertTSImportType(node: object | null | undefined, opts?: object | null): void;
+declare function isTSIndexSignature(node: object | null | undefined, opts?: object | null): node is TSIndexSignature;
+declare function assertTSIndexSignature(node: object | null | undefined, opts?: object | null): void;
+declare function isTSIndexedAccessType(node: object | null | undefined, opts?: object | null): node is TSIndexedAccessType;
+declare function assertTSIndexedAccessType(node: object | null | undefined, opts?: object | null): void;
+declare function isTSInferType(node: object | null | undefined, opts?: object | null): node is TSInferType;
+declare function assertTSInferType(node: object | null | undefined, opts?: object | null): void;
+declare function isTSInstantiationExpression(node: object | null | undefined, opts?: object | null): node is TSInstantiationExpression;
+declare function assertTSInstantiationExpression(node: object | null | undefined, opts?: object | null): void;
+declare function isTSInterfaceBody(node: object | null | undefined, opts?: object | null): node is TSInterfaceBody;
+declare function assertTSInterfaceBody(node: object | null | undefined, opts?: object | null): void;
+declare function isTSInterfaceDeclaration(node: object | null | undefined, opts?: object | null): node is TSInterfaceDeclaration;
+declare function assertTSInterfaceDeclaration(node: object | null | undefined, opts?: object | null): void;
+declare function isTSIntersectionType(node: object | null | undefined, opts?: object | null): node is TSIntersectionType;
+declare function assertTSIntersectionType(node: object | null | undefined, opts?: object | null): void;
+declare function isTSIntrinsicKeyword(node: object | null | undefined, opts?: object | null): node is TSIntrinsicKeyword;
+declare function assertTSIntrinsicKeyword(node: object | null | undefined, opts?: object | null): void;
+declare function isTSLiteralType(node: object | null | undefined, opts?: object | null): node is TSLiteralType;
+declare function assertTSLiteralType(node: object | null | undefined, opts?: object | null): void;
+declare function isTSMappedType(node: object | null | undefined, opts?: object | null): node is TSMappedType;
+declare function assertTSMappedType(node: object | null | undefined, opts?: object | null): void;
+declare function isTSMethodSignature(node: object | null | undefined, opts?: object | null): node is TSMethodSignature;
+declare function assertTSMethodSignature(node: object | null | undefined, opts?: object | null): void;
+declare function isTSModuleBlock(node: object | null | undefined, opts?: object | null): node is TSModuleBlock;
+declare function assertTSModuleBlock(node: object | null | undefined, opts?: object | null): void;
+declare function isTSModuleDeclaration(node: object | null | undefined, opts?: object | null): node is TSModuleDeclaration;
+declare function assertTSModuleDeclaration(node: object | null | undefined, opts?: object | null): void;
+declare function isTSNamedTupleMember(node: object | null | undefined, opts?: object | null): node is TSNamedTupleMember;
+declare function assertTSNamedTupleMember(node: object | null | undefined, opts?: object | null): void;
+declare function isTSNamespaceExportDeclaration(node: object | null | undefined, opts?: object | null): node is TSNamespaceExportDeclaration;
+declare function assertTSNamespaceExportDeclaration(node: object | null | undefined, opts?: object | null): void;
+declare function isTSNeverKeyword(node: object | null | undefined, opts?: object | null): node is TSNeverKeyword;
+declare function assertTSNeverKeyword(node: object | null | undefined, opts?: object | null): void;
+declare function isTSNonNullExpression(node: object | null | undefined, opts?: object | null): node is TSNonNullExpression;
+declare function assertTSNonNullExpression(node: object | null | undefined, opts?: object | null): void;
+declare function isTSNullKeyword(node: object | null | undefined, opts?: object | null): node is TSNullKeyword;
+declare function assertTSNullKeyword(node: object | null | undefined, opts?: object | null): void;
+declare function isTSNumberKeyword(node: object | null | undefined, opts?: object | null): node is TSNumberKeyword;
+declare function assertTSNumberKeyword(node: object | null | undefined, opts?: object | null): void;
+declare function isTSObjectKeyword(node: object | null | undefined, opts?: object | null): node is TSObjectKeyword;
+declare function assertTSObjectKeyword(node: object | null | undefined, opts?: object | null): void;
+declare function isTSOptionalType(node: object | null | undefined, opts?: object | null): node is TSOptionalType;
+declare function assertTSOptionalType(node: object | null | undefined, opts?: object | null): void;
+declare function isTSParameterProperty(node: object | null | undefined, opts?: object | null): node is TSParameterProperty;
+declare function assertTSParameterProperty(node: object | null | undefined, opts?: object | null): void;
+declare function isTSParenthesizedType(node: object | null | undefined, opts?: object | null): node is TSParenthesizedType;
+declare function assertTSParenthesizedType(node: object | null | undefined, opts?: object | null): void;
+declare function isTSPropertySignature(node: object | null | undefined, opts?: object | null): node is TSPropertySignature;
+declare function assertTSPropertySignature(node: object | null | undefined, opts?: object | null): void;
+declare function isTSQualifiedName(node: object | null | undefined, opts?: object | null): node is TSQualifiedName;
+declare function assertTSQualifiedName(node: object | null | undefined, opts?: object | null): void;
+declare function isTSRestType(node: object | null | undefined, opts?: object | null): node is TSRestType;
+declare function assertTSRestType(node: object | null | undefined, opts?: object | null): void;
+declare function isTSSatisfiesExpression(node: object | null | undefined, opts?: object | null): node is TSSatisfiesExpression;
+declare function assertTSSatisfiesExpression(node: object | null | undefined, opts?: object | null): void;
+declare function isTSStringKeyword(node: object | null | undefined, opts?: object | null): node is TSStringKeyword;
+declare function assertTSStringKeyword(node: object | null | undefined, opts?: object | null): void;
+declare function isTSSymbolKeyword(node: object | null | undefined, opts?: object | null): node is TSSymbolKeyword;
+declare function assertTSSymbolKeyword(node: object | null | undefined, opts?: object | null): void;
+declare function isTSTemplateLiteralType(node: object | null | undefined, opts?: object | null): node is TSTemplateLiteralType;
+declare function assertTSTemplateLiteralType(node: object | null | undefined, opts?: object | null): void;
+declare function isTSThisType(node: object | null | undefined, opts?: object | null): node is TSThisType;
+declare function assertTSThisType(node: object | null | undefined, opts?: object | null): void;
+declare function isTSTupleType(node: object | null | undefined, opts?: object | null): node is TSTupleType;
+declare function assertTSTupleType(node: object | null | undefined, opts?: object | null): void;
+declare function isTSType(node: object | null | undefined, opts?: object | null): node is TSType;
+declare function assertTSType(node: object | null | undefined, opts?: object | null): void;
+declare function isTSTypeAliasDeclaration(node: object | null | undefined, opts?: object | null): node is TSTypeAliasDeclaration;
+declare function assertTSTypeAliasDeclaration(node: object | null | undefined, opts?: object | null): void;
+declare function isTSTypeAnnotation(node: object | null | undefined, opts?: object | null): node is TSTypeAnnotation;
+declare function assertTSTypeAnnotation(node: object | null | undefined, opts?: object | null): void;
+declare function isTSTypeAssertion(node: object | null | undefined, opts?: object | null): node is TSTypeAssertion;
+declare function assertTSTypeAssertion(node: object | null | undefined, opts?: object | null): void;
+declare function isTSTypeElement(node: object | null | undefined, opts?: object | null): node is TSTypeElement;
+declare function assertTSTypeElement(node: object | null | undefined, opts?: object | null): void;
+declare function isTSTypeLiteral(node: object | null | undefined, opts?: object | null): node is TSTypeLiteral;
+declare function assertTSTypeLiteral(node: object | null | undefined, opts?: object | null): void;
+declare function isTSTypeOperator(node: object | null | undefined, opts?: object | null): node is TSTypeOperator;
+declare function assertTSTypeOperator(node: object | null | undefined, opts?: object | null): void;
+declare function isTSTypeParameter(node: object | null | undefined, opts?: object | null): node is TSTypeParameter;
+declare function assertTSTypeParameter(node: object | null | undefined, opts?: object | null): void;
+declare function isTSTypeParameterDeclaration(node: object | null | undefined, opts?: object | null): node is TSTypeParameterDeclaration;
+declare function assertTSTypeParameterDeclaration(node: object | null | undefined, opts?: object | null): void;
+declare function isTSTypeParameterInstantiation(node: object | null | undefined, opts?: object | null): node is TSTypeParameterInstantiation;
+declare function assertTSTypeParameterInstantiation(node: object | null | undefined, opts?: object | null): void;
+declare function isTSTypePredicate(node: object | null | undefined, opts?: object | null): node is TSTypePredicate;
+declare function assertTSTypePredicate(node: object | null | undefined, opts?: object | null): void;
+declare function isTSTypeQuery(node: object | null | undefined, opts?: object | null): node is TSTypeQuery;
+declare function assertTSTypeQuery(node: object | null | undefined, opts?: object | null): void;
+declare function isTSTypeReference(node: object | null | undefined, opts?: object | null): node is TSTypeReference;
+declare function assertTSTypeReference(node: object | null | undefined, opts?: object | null): void;
+declare function isTSUndefinedKeyword(node: object | null | undefined, opts?: object | null): node is TSUndefinedKeyword;
+declare function assertTSUndefinedKeyword(node: object | null | undefined, opts?: object | null): void;
+declare function isTSUnionType(node: object | null | undefined, opts?: object | null): node is TSUnionType;
+declare function assertTSUnionType(node: object | null | undefined, opts?: object | null): void;
+declare function isTSUnknownKeyword(node: object | null | undefined, opts?: object | null): node is TSUnknownKeyword;
+declare function assertTSUnknownKeyword(node: object | null | undefined, opts?: object | null): void;
+declare function isTSVoidKeyword(node: object | null | undefined, opts?: object | null): node is TSVoidKeyword;
+declare function assertTSVoidKeyword(node: object | null | undefined, opts?: object | null): void;
+declare function isTaggedTemplateExpression(node: object | null | undefined, opts?: object | null): node is TaggedTemplateExpression;
+declare function assertTaggedTemplateExpression(node: object | null | undefined, opts?: object | null): void;
+declare function isTemplateElement(node: object | null | undefined, opts?: object | null): node is TemplateElement;
+declare function assertTemplateElement(node: object | null | undefined, opts?: object | null): void;
+declare function isTemplateLiteral(node: object | null | undefined, opts?: object | null): node is TemplateLiteral;
+declare function assertTemplateLiteral(node: object | null | undefined, opts?: object | null): void;
+declare function isTerminatorless(node: object | null | undefined, opts?: object | null): node is Terminatorless;
+declare function assertTerminatorless(node: object | null | undefined, opts?: object | null): void;
+declare function isThisExpression(node: object | null | undefined, opts?: object | null): node is ThisExpression;
+declare function assertThisExpression(node: object | null | undefined, opts?: object | null): void;
+declare function isThisTypeAnnotation(node: object | null | undefined, opts?: object | null): node is ThisTypeAnnotation;
+declare function assertThisTypeAnnotation(node: object | null | undefined, opts?: object | null): void;
+declare function isThrowStatement(node: object | null | undefined, opts?: object | null): node is ThrowStatement;
+declare function assertThrowStatement(node: object | null | undefined, opts?: object | null): void;
+declare function isTopicReference(node: object | null | undefined, opts?: object | null): node is TopicReference;
+declare function assertTopicReference(node: object | null | undefined, opts?: object | null): void;
+declare function isTryStatement(node: object | null | undefined, opts?: object | null): node is TryStatement;
+declare function assertTryStatement(node: object | null | undefined, opts?: object | null): void;
+declare function isTupleExpression(node: object | null | undefined, opts?: object | null): node is TupleExpression;
+declare function assertTupleExpression(node: object | null | undefined, opts?: object | null): void;
+declare function isTupleTypeAnnotation(node: object | null | undefined, opts?: object | null): node is TupleTypeAnnotation;
+declare function assertTupleTypeAnnotation(node: object | null | undefined, opts?: object | null): void;
+declare function isTypeAlias(node: object | null | undefined, opts?: object | null): node is TypeAlias;
+declare function assertTypeAlias(node: object | null | undefined, opts?: object | null): void;
+declare function isTypeAnnotation(node: object | null | undefined, opts?: object | null): node is TypeAnnotation;
+declare function assertTypeAnnotation(node: object | null | undefined, opts?: object | null): void;
+declare function isTypeCastExpression(node: object | null | undefined, opts?: object | null): node is TypeCastExpression;
+declare function assertTypeCastExpression(node: object | null | undefined, opts?: object | null): void;
+declare function isTypeParameter(node: object | null | undefined, opts?: object | null): node is TypeParameter;
+declare function assertTypeParameter(node: object | null | undefined, opts?: object | null): void;
+declare function isTypeParameterDeclaration(node: object | null | undefined, opts?: object | null): node is TypeParameterDeclaration;
+declare function assertTypeParameterDeclaration(node: object | null | undefined, opts?: object | null): void;
+declare function isTypeParameterInstantiation(node: object | null | undefined, opts?: object | null): node is TypeParameterInstantiation;
+declare function assertTypeParameterInstantiation(node: object | null | undefined, opts?: object | null): void;
+declare function isTypeScript(node: object | null | undefined, opts?: object | null): node is TypeScript;
+declare function assertTypeScript(node: object | null | undefined, opts?: object | null): void;
+declare function isTypeofTypeAnnotation(node: object | null | undefined, opts?: object | null): node is TypeofTypeAnnotation;
+declare function assertTypeofTypeAnnotation(node: object | null | undefined, opts?: object | null): void;
+declare function isUnaryExpression(node: object | null | undefined, opts?: object | null): node is UnaryExpression;
+declare function assertUnaryExpression(node: object | null | undefined, opts?: object | null): void;
+declare function isUnaryLike(node: object | null | undefined, opts?: object | null): node is UnaryLike;
+declare function assertUnaryLike(node: object | null | undefined, opts?: object | null): void;
+declare function isUnionTypeAnnotation(node: object | null | undefined, opts?: object | null): node is UnionTypeAnnotation;
+declare function assertUnionTypeAnnotation(node: object | null | undefined, opts?: object | null): void;
+declare function isUpdateExpression(node: object | null | undefined, opts?: object | null): node is UpdateExpression;
+declare function assertUpdateExpression(node: object | null | undefined, opts?: object | null): void;
+declare function isUserWhitespacable(node: object | null | undefined, opts?: object | null): node is UserWhitespacable;
+declare function assertUserWhitespacable(node: object | null | undefined, opts?: object | null): void;
+declare function isV8IntrinsicIdentifier(node: object | null | undefined, opts?: object | null): node is V8IntrinsicIdentifier;
+declare function assertV8IntrinsicIdentifier(node: object | null | undefined, opts?: object | null): void;
+declare function isVariableDeclaration(node: object | null | undefined, opts?: object | null): node is VariableDeclaration;
+declare function assertVariableDeclaration(node: object | null | undefined, opts?: object | null): void;
+declare function isVariableDeclarator(node: object | null | undefined, opts?: object | null): node is VariableDeclarator;
+declare function assertVariableDeclarator(node: object | null | undefined, opts?: object | null): void;
+declare function isVariance(node: object | null | undefined, opts?: object | null): node is Variance;
+declare function assertVariance(node: object | null | undefined, opts?: object | null): void;
+declare function isVoidPattern(node: object | null | undefined, opts?: object | null): node is VoidPattern;
+declare function assertVoidPattern(node: object | null | undefined, opts?: object | null): void;
+declare function isVoidTypeAnnotation(node: object | null | undefined, opts?: object | null): node is VoidTypeAnnotation;
+declare function assertVoidTypeAnnotation(node: object | null | undefined, opts?: object | null): void;
+declare function isWhile(node: object | null | undefined, opts?: object | null): node is While;
+declare function assertWhile(node: object | null | undefined, opts?: object | null): void;
+declare function isWhileStatement(node: object | null | undefined, opts?: object | null): node is WhileStatement;
+declare function assertWhileStatement(node: object | null | undefined, opts?: object | null): void;
+declare function isWithStatement(node: object | null | undefined, opts?: object | null): node is WithStatement;
+declare function assertWithStatement(node: object | null | undefined, opts?: object | null): void;
+declare function isYieldExpression(node: object | null | undefined, opts?: object | null): node is YieldExpression;
+declare function assertYieldExpression(node: object | null | undefined, opts?: object | null): void;
+declare function assertNode(obj: any): void;
+declare function createTypeAnnotationBasedOnTypeof(type: 'string' | 'number' | 'undefined' | 'boolean' | 'function' | 'object' | 'symbol'): StringTypeAnnotation | VoidTypeAnnotation | NumberTypeAnnotation | BooleanTypeAnnotation | GenericTypeAnnotation;
+declare function createUnionTypeAnnotation<T extends FlowType>(types: [T]): T;
+declare function createFlowUnionType<T extends FlowType>(types: [T]): T;
+declare function createUnionTypeAnnotation(types: ReadonlyArray<FlowType>): UnionTypeAnnotation;
+declare function createFlowUnionType(types: ReadonlyArray<FlowType>): UnionTypeAnnotation;
+declare function buildChildren(node: {
+  children: ReadonlyArray<JSXText | JSXExpressionContainer | JSXSpreadChild | JSXElement | JSXFragment | JSXEmptyExpression>;
+}): JSXElement['children'];
+declare function clone<T extends Node>(n: T): T;
+declare function cloneDeep<T extends Node>(n: T): T;
+declare function cloneDeepWithoutLoc<T extends Node>(n: T): T;
+declare function cloneNode<T extends Node>(n: T, deep?: boolean, withoutLoc?: boolean): T;
+declare function cloneWithoutLoc<T extends Node>(n: T): T;
+type CommentTypeShorthand = 'leading' | 'inner' | 'trailing';
+declare function addComment<T extends Node>(node: T, type: CommentTypeShorthand, content: string, line?: boolean): T;
+declare function addComments<T extends Node>(node: T, type: CommentTypeShorthand, comments: ReadonlyArray<Comment>): T;
+declare function inheritInnerComments(node: Node, parent: Node): void;
+declare function inheritLeadingComments(node: Node, parent: Node): void;
+declare function inheritsComments<T extends Node>(node: T, parent: Node): void;
+declare function inheritTrailingComments(node: Node, parent: Node): void;
+declare function removeComments<T extends Node>(node: T): T;
+declare function ensureBlock(node: Extract<Node, {
+  body: BlockStatement | Statement | Expression;
+}>): BlockStatement;
+declare function ensureBlock<K extends keyof Extract<Node, {
+  body: BlockStatement | Statement | Expression;
+}> = 'body'>(node: Extract<Node, Record<K, BlockStatement | Statement | Expression>>, key: K): BlockStatement;
+declare function toBindingIdentifierName(name: {
+  toString(): string;
+} | null | undefined): string;
+declare function toBlock(node: Statement | Expression, parent?: Function | null): BlockStatement;
+declare function toComputedKey<T extends Extract<Node, {
+  computed: boolean | null;
+}>>(node: T, key?: Expression | Identifier): Expression;
+declare function toExpression(node: Function): FunctionExpression;
+declare function toExpression(node: Class): ClassExpression;
+declare function toExpression(node: ExpressionStatement | Expression | Class | Function): Expression;
+declare function toIdentifier(name: {
+  toString(): string;
+} | null | undefined): string;
+declare function toKeyAlias(node: Method | Property, key?: Node): string;
+declare function toSequenceExpression(nodes: ReadonlyArray<Node>, scope: {
+  push(value: {
+    id: LVal;
+    kind: 'var';
+    init?: Expression;
+  }): void;
+  buildUndefinedNode(): Node;
+}): SequenceExpression | undefined;
+declare function toStatement(node: AssignmentExpression, ignore?: boolean): ExpressionStatement;
+declare function toStatement(node: Statement | AssignmentExpression, ignore?: boolean): Statement;
+declare function toStatement(node: Class, ignore: true): ClassDeclaration | undefined;
+declare function toStatement(node: Class, ignore?: boolean): ClassDeclaration;
+declare function toStatement(node: Function, ignore: true): FunctionDeclaration | undefined;
+declare function toStatement(node: Function, ignore?: boolean): FunctionDeclaration;
+declare function toStatement(node: Statement | Class | Function | AssignmentExpression, ignore: true): Statement | undefined;
+declare function toStatement(node: Statement | Class | Function | AssignmentExpression, ignore?: boolean): Statement;
+declare function valueToNode(value: undefined): Identifier;
+declare function valueToNode(value: boolean): BooleanLiteral;
+declare function valueToNode(value: null): NullLiteral;
+declare function valueToNode(value: string): StringLiteral;
+declare function valueToNode(value: number): NumericLiteral | BinaryExpression | UnaryExpression;
+declare function valueToNode(value: RegExp): RegExpLiteral;
+declare function valueToNode(value: ReadonlyArray<undefined | boolean | null | string | number | RegExp | object>): ArrayExpression;
+declare function valueToNode(value: object): ObjectExpression;
+declare function valueToNode(value: undefined | boolean | null | string | number | RegExp | object): Expression;
+declare function removeTypeDuplicates(types: ReadonlyArray<FlowType | false | null | undefined>): FlowType[];
+declare function appendToMemberExpression<T extends Pick<MemberExpression, 'object' | 'property'>>(member: T, append: MemberExpression['property'], computed?: boolean): T;
+declare function inherits<T extends Node | null | undefined>(child: T, parent: Node | null | undefined): T;
+declare function prependToMemberExpression<T extends Pick<MemberExpression, 'object' | 'property'>>(member: T, prepend: MemberExpression['object']): T;
+declare function removeProperties(n: Node, opts?: {
+  preserveComments: boolean;
+} | null): void;
+declare function removePropertiesDeep<T extends Node>(n: T, opts?: {
+  preserveComments: boolean;
+} | null): T;
+declare function getBindingIdentifiers(node: Node, duplicates: true, outerOnly?: boolean): Record<string, Array<Identifier>>;
+declare function getBindingIdentifiers(node: Node, duplicates?: false, outerOnly?: boolean): Record<string, Identifier>;
+declare function getBindingIdentifiers(node: Node, duplicates: boolean, outerOnly?: boolean): Record<string, Identifier | Array<Identifier>>;
+declare function getOuterBindingIdentifiers(node: Node, duplicates: true): Record<string, Array<Identifier>>;
+declare function getOuterBindingIdentifiers(node: Node, duplicates?: false): Record<string, Identifier>;
+declare function getOuterBindingIdentifiers(node: Node, duplicates: boolean): Record<string, Identifier | Array<Identifier>>;
+type TraversalAncestors = ReadonlyArray<{
+  node: Node;
+  key: string;
+  index?: number;
+}>;
+type TraversalHandler<T> = (this: undefined, node: Node, parent: TraversalAncestors, type: T) => void;
+type TraversalHandlers<T> = {
+  enter?: TraversalHandler<T>;
+  exit?: TraversalHandler<T>;
+};
+declare function traverse<T>(n: Node, h: TraversalHandler<T> | TraversalHandlers<T>, state?: T): void;
+declare function traverseFast<T>(n: Node, h: TraversalHandler<T>, state?: T): void;
+declare function shallowEqual<T extends object>(actual: object, expected: T): actual is T;
+declare function buildMatchMemberExpression(match: string, allowPartial?: boolean): (node: Node | null | undefined) => node is MemberExpression;
+declare function is<T extends Node['type']>(type: T, n: Node | null | undefined, required?: undefined): n is Extract<Node, {
+  type: T;
+}>;
+declare function is<T extends Node['type'], P extends Extract<Node, {
+  type: T;
+}>>(type: T, n: Node | null | undefined, required: Partial<P>): n is P;
+declare function is<P extends Node>(type: string, n: Node | null | undefined, required: Partial<P>): n is P;
+declare function is(type: string, n: Node | null | undefined, required?: Partial<Node>): n is Node;
+declare function isBinding(node: Node, parent: Node, grandparent?: Node): boolean;
+declare function isBlockScoped(node: Node): node is FunctionDeclaration | ClassDeclaration | VariableDeclaration;
+declare function isImmutable(node: Node): node is Immutable;
+declare function isLet(node: Node): node is VariableDeclaration;
+declare function isNode(node: object | null | undefined): node is Node;
+declare function isNodesEquivalent<T extends Partial<Node>>(a: T, b: any): b is T;
+declare function isNodesEquivalent(a: any, b: any): boolean;
+declare function isPlaceholderType(placeholderType: Node['type'], targetType: Node['type']): boolean;
+declare function isReferenced(node: Node, parent: Node, grandparent?: Node): boolean;
+declare function isScope(node: Node, parent: Node): node is Scopable;
+declare function isSpecifierDefault(specifier: ModuleSpecifier): boolean;
+declare function isType<T extends Node['type']>(nodetype: string, targetType: T): nodetype is T;
+declare function isType(nodetype: string | null | undefined, targetType: string): boolean;
+declare function isValidES3Identifier(name: string): boolean;
+declare function isValidIdentifier(name: string): boolean;
+declare function isVar(node: Node): node is VariableDeclaration;
+declare function matchesPattern(node: Node | null | undefined, match: string | ReadonlyArray<string>, allowPartial?: boolean): node is MemberExpression;
+declare function validate<T extends Node, K extends keyof T>(n: Node | null | undefined, key: K, value: T[K]): void;
+declare function validate(n: Node, key: string, value: any): void;
+//#endregion
+//#region src/plugin/index.d.ts
+type PluginOptions = {
+  /** Override the filename baked into each object. Defaults to basename(state.filename). */filename?: string;
+};
+type BabelApi = {
+  types: typeof index_legacy_d_exports;
+};
+declare const plugin: ({
+  types: t
+}: BabelApi) => PluginObj<PluginPass>;
+//#endregion
+export { PluginOptions, plugin as default };