hermes-estree 0.5.0

package/dist/generated/HermesESTreeSelectorTypes.js.flow

@@ -0,0 +1,3138 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict
+ * @format
+ */
+
+'use strict';
+
+import type {
+  AnyTypeAnnotation,
+  ArrayExpression,
+  ArrayPattern,
+  ArrayTypeAnnotation,
+  ArrowFunctionExpression,
+  AssignmentExpression,
+  AssignmentPattern,
+  AwaitExpression,
+  BinaryExpression,
+  BlockStatement,
+  BooleanLiteralTypeAnnotation,
+  BooleanTypeAnnotation,
+  BreakStatement,
+  CallExpression,
+  CatchClause,
+  ClassBody,
+  ClassDeclaration,
+  ClassExpression,
+  ClassImplements,
+  ClassPrivateProperty,
+  ClassProperty,
+  ConditionalExpression,
+  ContinueStatement,
+  DebuggerStatement,
+  DeclareClass,
+  DeclaredPredicate,
+  DeclareExportAllDeclaration,
+  DeclareExportDeclaration,
+  DeclareFunction,
+  DeclareInterface,
+  DeclareModule,
+  DeclareModuleExports,
+  DeclareOpaqueType,
+  DeclareTypeAlias,
+  DeclareVariable,
+  DoWhileStatement,
+  EmptyStatement,
+  EmptyTypeAnnotation,
+  EnumBooleanBody,
+  EnumBooleanMember,
+  EnumDeclaration,
+  EnumDefaultedMember,
+  EnumNumberBody,
+  EnumNumberMember,
+  EnumStringBody,
+  EnumStringMember,
+  EnumSymbolBody,
+  ExistsTypeAnnotation,
+  ExportAllDeclaration,
+  ExportDefaultDeclaration,
+  ExportNamedDeclaration,
+  ExportNamespaceSpecifier,
+  ExportSpecifier,
+  ExpressionStatement,
+  ForInStatement,
+  ForOfStatement,
+  ForStatement,
+  FunctionDeclaration,
+  FunctionExpression,
+  FunctionTypeAnnotation,
+  FunctionTypeParam,
+  GenericTypeAnnotation,
+  Identifier,
+  IfStatement,
+  ImportAttribute,
+  ImportDeclaration,
+  ImportDefaultSpecifier,
+  ImportExpression,
+  ImportNamespaceSpecifier,
+  ImportSpecifier,
+  IndexedAccessType,
+  InferredPredicate,
+  InterfaceDeclaration,
+  InterfaceExtends,
+  InterfaceTypeAnnotation,
+  IntersectionTypeAnnotation,
+  JSXAttribute,
+  JSXClosingElement,
+  JSXClosingFragment,
+  JSXElement,
+  JSXEmptyExpression,
+  JSXExpressionContainer,
+  JSXFragment,
+  JSXIdentifier,
+  JSXMemberExpression,
+  JSXNamespacedName,
+  JSXOpeningElement,
+  JSXOpeningFragment,
+  JSXSpreadAttribute,
+  JSXSpreadChild,
+  JSXText,
+  LabeledStatement,
+  LogicalExpression,
+  MemberExpression,
+  MetaProperty,
+  MethodDefinition,
+  MixedTypeAnnotation,
+  NewExpression,
+  NullableTypeAnnotation,
+  NullLiteralTypeAnnotation,
+  NumberLiteralTypeAnnotation,
+  NumberTypeAnnotation,
+  ObjectExpression,
+  ObjectPattern,
+  ObjectTypeAnnotation,
+  ObjectTypeCallProperty,
+  ObjectTypeIndexer,
+  ObjectTypeInternalSlot,
+  ObjectTypeProperty,
+  ObjectTypeSpreadProperty,
+  OpaqueType,
+  OptionalCallExpression,
+  OptionalIndexedAccessType,
+  OptionalMemberExpression,
+  PrivateName,
+  Program,
+  Property,
+  QualifiedTypeIdentifier,
+  RestElement,
+  ReturnStatement,
+  SequenceExpression,
+  SpreadElement,
+  StringLiteralTypeAnnotation,
+  StringTypeAnnotation,
+  Super,
+  SwitchCase,
+  SwitchStatement,
+  SymbolTypeAnnotation,
+  TaggedTemplateExpression,
+  TemplateElement,
+  TemplateLiteral,
+  ThisExpression,
+  ThisTypeAnnotation,
+  ThrowStatement,
+  TryStatement,
+  TupleTypeAnnotation,
+  TypeAlias,
+  TypeAnnotation,
+  TypeCastExpression,
+  TypeofTypeAnnotation,
+  TypeParameter,
+  TypeParameterDeclaration,
+  TypeParameterInstantiation,
+  UnaryExpression,
+  UnionTypeAnnotation,
+  UpdateExpression,
+  VariableDeclaration,
+  VariableDeclarator,
+  Variance,
+  VoidTypeAnnotation,
+  WhileStatement,
+  WithStatement,
+  YieldExpression,
+  Literal,
+} from '../types';
+
+interface ArrayExpression_With_elements extends ArrayExpression {
+  +elements: $NonMaybeType<ArrayExpression['elements']>;
+}
+interface ArrayExpression_With_trailingComma extends ArrayExpression {
+  +trailingComma: $NonMaybeType<ArrayExpression['trailingComma']>;
+}
+interface ArrayPattern_With_elements extends ArrayPattern {
+  +elements: $NonMaybeType<ArrayPattern['elements']>;
+}
+interface ArrayPattern_With_typeAnnotation extends ArrayPattern {
+  +typeAnnotation: $NonMaybeType<ArrayPattern['typeAnnotation']>;
+}
+interface ArrayTypeAnnotation_With_elementType extends ArrayTypeAnnotation {
+  +elementType: $NonMaybeType<ArrayTypeAnnotation['elementType']>;
+}
+interface ArrowFunctionExpression_With_id extends ArrowFunctionExpression {
+  +id: $NonMaybeType<ArrowFunctionExpression['id']>;
+}
+interface ArrowFunctionExpression_With_params extends ArrowFunctionExpression {
+  +params: $NonMaybeType<ArrowFunctionExpression['params']>;
+}
+interface ArrowFunctionExpression_With_body extends ArrowFunctionExpression {
+  +body: $NonMaybeType<ArrowFunctionExpression['body']>;
+}
+interface ArrowFunctionExpression_With_typeParameters
+  extends ArrowFunctionExpression {
+  +typeParameters: $NonMaybeType<ArrowFunctionExpression['typeParameters']>;
+}
+interface ArrowFunctionExpression_With_returnType
+  extends ArrowFunctionExpression {
+  +returnType: $NonMaybeType<ArrowFunctionExpression['returnType']>;
+}
+interface ArrowFunctionExpression_With_predicate
+  extends ArrowFunctionExpression {
+  +predicate: $NonMaybeType<ArrowFunctionExpression['predicate']>;
+}
+interface ArrowFunctionExpression_With_expression
+  extends ArrowFunctionExpression {
+  +expression: $NonMaybeType<ArrowFunctionExpression['expression']>;
+}
+interface ArrowFunctionExpression_With_async extends ArrowFunctionExpression {
+  +async: $NonMaybeType<ArrowFunctionExpression['async']>;
+}
+interface AssignmentExpression_With_operator extends AssignmentExpression {
+  +operator: $NonMaybeType<AssignmentExpression['operator']>;
+}
+interface AssignmentExpression_With_left extends AssignmentExpression {
+  +left: $NonMaybeType<AssignmentExpression['left']>;
+}
+interface AssignmentExpression_With_right extends AssignmentExpression {
+  +right: $NonMaybeType<AssignmentExpression['right']>;
+}
+interface AssignmentPattern_With_left extends AssignmentPattern {
+  +left: $NonMaybeType<AssignmentPattern['left']>;
+}
+interface AssignmentPattern_With_right extends AssignmentPattern {
+  +right: $NonMaybeType<AssignmentPattern['right']>;
+}
+interface AwaitExpression_With_argument extends AwaitExpression {
+  +argument: $NonMaybeType<AwaitExpression['argument']>;
+}
+interface BinaryExpression_With_left extends BinaryExpression {
+  +left: $NonMaybeType<BinaryExpression['left']>;
+}
+interface BinaryExpression_With_right extends BinaryExpression {
+  +right: $NonMaybeType<BinaryExpression['right']>;
+}
+interface BinaryExpression_With_operator extends BinaryExpression {
+  +operator: $NonMaybeType<BinaryExpression['operator']>;
+}
+interface BlockStatement_With_body extends BlockStatement {
+  +body: $NonMaybeType<BlockStatement['body']>;
+}
+interface BooleanLiteralTypeAnnotation_With_value
+  extends BooleanLiteralTypeAnnotation {
+  +value: $NonMaybeType<BooleanLiteralTypeAnnotation['value']>;
+}
+interface BooleanLiteralTypeAnnotation_With_raw
+  extends BooleanLiteralTypeAnnotation {
+  +raw: $NonMaybeType<BooleanLiteralTypeAnnotation['raw']>;
+}
+interface BreakStatement_With_label extends BreakStatement {
+  +label: $NonMaybeType<BreakStatement['label']>;
+}
+interface CallExpression_With_callee extends CallExpression {
+  +callee: $NonMaybeType<CallExpression['callee']>;
+}
+interface CallExpression_With_typeArguments extends CallExpression {
+  +typeArguments: $NonMaybeType<CallExpression['typeArguments']>;
+}
+interface CallExpression_With_arguments extends CallExpression {
+  +arguments: $NonMaybeType<CallExpression['arguments']>;
+}
+interface CatchClause_With_param extends CatchClause {
+  +param: $NonMaybeType<CatchClause['param']>;
+}
+interface CatchClause_With_body extends CatchClause {
+  +body: $NonMaybeType<CatchClause['body']>;
+}
+interface ClassBody_With_body extends ClassBody {
+  +body: $NonMaybeType<ClassBody['body']>;
+}
+interface ClassDeclaration_With_id extends ClassDeclaration {
+  +id: $NonMaybeType<ClassDeclaration['id']>;
+}
+interface ClassDeclaration_With_typeParameters extends ClassDeclaration {
+  +typeParameters: $NonMaybeType<ClassDeclaration['typeParameters']>;
+}
+interface ClassDeclaration_With_superClass extends ClassDeclaration {
+  +superClass: $NonMaybeType<ClassDeclaration['superClass']>;
+}
+interface ClassDeclaration_With_superTypeParameters extends ClassDeclaration {
+  +superTypeParameters: $NonMaybeType<ClassDeclaration['superTypeParameters']>;
+}
+interface ClassDeclaration_With_implements extends ClassDeclaration {
+  +implements: $NonMaybeType<ClassDeclaration['implements']>;
+}
+interface ClassDeclaration_With_decorators extends ClassDeclaration {
+  +decorators: $NonMaybeType<ClassDeclaration['decorators']>;
+}
+interface ClassDeclaration_With_body extends ClassDeclaration {
+  +body: $NonMaybeType<ClassDeclaration['body']>;
+}
+interface ClassExpression_With_id extends ClassExpression {
+  +id: $NonMaybeType<ClassExpression['id']>;
+}
+interface ClassExpression_With_typeParameters extends ClassExpression {
+  +typeParameters: $NonMaybeType<ClassExpression['typeParameters']>;
+}
+interface ClassExpression_With_superClass extends ClassExpression {
+  +superClass: $NonMaybeType<ClassExpression['superClass']>;
+}
+interface ClassExpression_With_superTypeParameters extends ClassExpression {
+  +superTypeParameters: $NonMaybeType<ClassExpression['superTypeParameters']>;
+}
+interface ClassExpression_With_implements extends ClassExpression {
+  +implements: $NonMaybeType<ClassExpression['implements']>;
+}
+interface ClassExpression_With_decorators extends ClassExpression {
+  +decorators: $NonMaybeType<ClassExpression['decorators']>;
+}
+interface ClassExpression_With_body extends ClassExpression {
+  +body: $NonMaybeType<ClassExpression['body']>;
+}
+interface ClassImplements_With_id extends ClassImplements {
+  +id: $NonMaybeType<ClassImplements['id']>;
+}
+interface ClassImplements_With_typeParameters extends ClassImplements {
+  +typeParameters: $NonMaybeType<ClassImplements['typeParameters']>;
+}
+interface ClassPrivateProperty_With_key extends ClassPrivateProperty {
+  +key: $NonMaybeType<ClassPrivateProperty['key']>;
+}
+interface ClassPrivateProperty_With_value extends ClassPrivateProperty {
+  +value: $NonMaybeType<ClassPrivateProperty['value']>;
+}
+interface ClassPrivateProperty_With_static extends ClassPrivateProperty {
+  +static: $NonMaybeType<ClassPrivateProperty['static']>;
+}
+interface ClassPrivateProperty_With_declare extends ClassPrivateProperty {
+  +declare: $NonMaybeType<ClassPrivateProperty['declare']>;
+}
+interface ClassPrivateProperty_With_optional extends ClassPrivateProperty {
+  +optional: $NonMaybeType<ClassPrivateProperty['optional']>;
+}
+interface ClassPrivateProperty_With_variance extends ClassPrivateProperty {
+  +variance: $NonMaybeType<ClassPrivateProperty['variance']>;
+}
+interface ClassPrivateProperty_With_typeAnnotation
+  extends ClassPrivateProperty {
+  +typeAnnotation: $NonMaybeType<ClassPrivateProperty['typeAnnotation']>;
+}
+interface ClassProperty_With_key extends ClassProperty {
+  +key: $NonMaybeType<ClassProperty['key']>;
+}
+interface ClassProperty_With_value extends ClassProperty {
+  +value: $NonMaybeType<ClassProperty['value']>;
+}
+interface ClassProperty_With_computed extends ClassProperty {
+  +computed: $NonMaybeType<ClassProperty['computed']>;
+}
+interface ClassProperty_With_static extends ClassProperty {
+  +static: $NonMaybeType<ClassProperty['static']>;
+}
+interface ClassProperty_With_declare extends ClassProperty {
+  +declare: $NonMaybeType<ClassProperty['declare']>;
+}
+interface ClassProperty_With_optional extends ClassProperty {
+  +optional: $NonMaybeType<ClassProperty['optional']>;
+}
+interface ClassProperty_With_variance extends ClassProperty {
+  +variance: $NonMaybeType<ClassProperty['variance']>;
+}
+interface ClassProperty_With_typeAnnotation extends ClassProperty {
+  +typeAnnotation: $NonMaybeType<ClassProperty['typeAnnotation']>;
+}
+interface ConditionalExpression_With_test extends ConditionalExpression {
+  +test: $NonMaybeType<ConditionalExpression['test']>;
+}
+interface ConditionalExpression_With_alternate extends ConditionalExpression {
+  +alternate: $NonMaybeType<ConditionalExpression['alternate']>;
+}
+interface ConditionalExpression_With_consequent extends ConditionalExpression {
+  +consequent: $NonMaybeType<ConditionalExpression['consequent']>;
+}
+interface ContinueStatement_With_label extends ContinueStatement {
+  +label: $NonMaybeType<ContinueStatement['label']>;
+}
+interface DeclareClass_With_id extends DeclareClass {
+  +id: $NonMaybeType<DeclareClass['id']>;
+}
+interface DeclareClass_With_typeParameters extends DeclareClass {
+  +typeParameters: $NonMaybeType<DeclareClass['typeParameters']>;
+}
+interface DeclareClass_With_extends extends DeclareClass {
+  +extends: $NonMaybeType<DeclareClass['extends']>;
+}
+interface DeclareClass_With_implements extends DeclareClass {
+  +implements: $NonMaybeType<DeclareClass['implements']>;
+}
+interface DeclareClass_With_mixins extends DeclareClass {
+  +mixins: $NonMaybeType<DeclareClass['mixins']>;
+}
+interface DeclareClass_With_body extends DeclareClass {
+  +body: $NonMaybeType<DeclareClass['body']>;
+}
+interface DeclaredPredicate_With_value extends DeclaredPredicate {
+  +value: $NonMaybeType<DeclaredPredicate['value']>;
+}
+interface DeclareExportAllDeclaration_With_source
+  extends DeclareExportAllDeclaration {
+  +source: $NonMaybeType<DeclareExportAllDeclaration['source']>;
+}
+interface DeclareExportDeclaration_With_declaration
+  extends DeclareExportDeclaration {
+  +declaration: $NonMaybeType<DeclareExportDeclaration['declaration']>;
+}
+interface DeclareExportDeclaration_With_specifiers
+  extends DeclareExportDeclaration {
+  +specifiers: $NonMaybeType<DeclareExportDeclaration['specifiers']>;
+}
+interface DeclareExportDeclaration_With_source
+  extends DeclareExportDeclaration {
+  +source: $NonMaybeType<DeclareExportDeclaration['source']>;
+}
+interface DeclareExportDeclaration_With_default
+  extends DeclareExportDeclaration {
+  +default: $NonMaybeType<DeclareExportDeclaration['default']>;
+}
+interface DeclareFunction_With_id extends DeclareFunction {
+  +id: $NonMaybeType<DeclareFunction['id']>;
+}
+interface DeclareFunction_With_predicate extends DeclareFunction {
+  +predicate: $NonMaybeType<DeclareFunction['predicate']>;
+}
+interface DeclareInterface_With_id extends DeclareInterface {
+  +id: $NonMaybeType<DeclareInterface['id']>;
+}
+interface DeclareInterface_With_typeParameters extends DeclareInterface {
+  +typeParameters: $NonMaybeType<DeclareInterface['typeParameters']>;
+}
+interface DeclareInterface_With_extends extends DeclareInterface {
+  +extends: $NonMaybeType<DeclareInterface['extends']>;
+}
+interface DeclareInterface_With_body extends DeclareInterface {
+  +body: $NonMaybeType<DeclareInterface['body']>;
+}
+interface DeclareModule_With_id extends DeclareModule {
+  +id: $NonMaybeType<DeclareModule['id']>;
+}
+interface DeclareModule_With_body extends DeclareModule {
+  +body: $NonMaybeType<DeclareModule['body']>;
+}
+interface DeclareModule_With_kind extends DeclareModule {
+  +kind: $NonMaybeType<DeclareModule['kind']>;
+}
+interface DeclareModuleExports_With_typeAnnotation
+  extends DeclareModuleExports {
+  +typeAnnotation: $NonMaybeType<DeclareModuleExports['typeAnnotation']>;
+}
+interface DeclareOpaqueType_With_id extends DeclareOpaqueType {
+  +id: $NonMaybeType<DeclareOpaqueType['id']>;
+}
+interface DeclareOpaqueType_With_typeParameters extends DeclareOpaqueType {
+  +typeParameters: $NonMaybeType<DeclareOpaqueType['typeParameters']>;
+}
+interface DeclareOpaqueType_With_impltype extends DeclareOpaqueType {
+  +impltype: $NonMaybeType<DeclareOpaqueType['impltype']>;
+}
+interface DeclareOpaqueType_With_supertype extends DeclareOpaqueType {
+  +supertype: $NonMaybeType<DeclareOpaqueType['supertype']>;
+}
+interface DeclareTypeAlias_With_id extends DeclareTypeAlias {
+  +id: $NonMaybeType<DeclareTypeAlias['id']>;
+}
+interface DeclareTypeAlias_With_typeParameters extends DeclareTypeAlias {
+  +typeParameters: $NonMaybeType<DeclareTypeAlias['typeParameters']>;
+}
+interface DeclareTypeAlias_With_right extends DeclareTypeAlias {
+  +right: $NonMaybeType<DeclareTypeAlias['right']>;
+}
+interface DeclareVariable_With_id extends DeclareVariable {
+  +id: $NonMaybeType<DeclareVariable['id']>;
+}
+interface DoWhileStatement_With_body extends DoWhileStatement {
+  +body: $NonMaybeType<DoWhileStatement['body']>;
+}
+interface DoWhileStatement_With_test extends DoWhileStatement {
+  +test: $NonMaybeType<DoWhileStatement['test']>;
+}
+interface EnumBooleanBody_With_members extends EnumBooleanBody {
+  +members: $NonMaybeType<EnumBooleanBody['members']>;
+}
+interface EnumBooleanBody_With_explicitType extends EnumBooleanBody {
+  +explicitType: $NonMaybeType<EnumBooleanBody['explicitType']>;
+}
+interface EnumBooleanBody_With_hasUnknownMembers extends EnumBooleanBody {
+  +hasUnknownMembers: $NonMaybeType<EnumBooleanBody['hasUnknownMembers']>;
+}
+interface EnumBooleanMember_With_id extends EnumBooleanMember {
+  +id: $NonMaybeType<EnumBooleanMember['id']>;
+}
+interface EnumBooleanMember_With_init extends EnumBooleanMember {
+  +init: $NonMaybeType<EnumBooleanMember['init']>;
+}
+interface EnumDeclaration_With_id extends EnumDeclaration {
+  +id: $NonMaybeType<EnumDeclaration['id']>;
+}
+interface EnumDeclaration_With_body extends EnumDeclaration {
+  +body: $NonMaybeType<EnumDeclaration['body']>;
+}
+interface EnumDefaultedMember_With_id extends EnumDefaultedMember {
+  +id: $NonMaybeType<EnumDefaultedMember['id']>;
+}
+interface EnumNumberBody_With_members extends EnumNumberBody {
+  +members: $NonMaybeType<EnumNumberBody['members']>;
+}
+interface EnumNumberBody_With_explicitType extends EnumNumberBody {
+  +explicitType: $NonMaybeType<EnumNumberBody['explicitType']>;
+}
+interface EnumNumberBody_With_hasUnknownMembers extends EnumNumberBody {
+  +hasUnknownMembers: $NonMaybeType<EnumNumberBody['hasUnknownMembers']>;
+}
+interface EnumNumberMember_With_id extends EnumNumberMember {
+  +id: $NonMaybeType<EnumNumberMember['id']>;
+}
+interface EnumNumberMember_With_init extends EnumNumberMember {
+  +init: $NonMaybeType<EnumNumberMember['init']>;
+}
+interface EnumStringBody_With_members extends EnumStringBody {
+  +members: $NonMaybeType<EnumStringBody['members']>;
+}
+interface EnumStringBody_With_explicitType extends EnumStringBody {
+  +explicitType: $NonMaybeType<EnumStringBody['explicitType']>;
+}
+interface EnumStringBody_With_hasUnknownMembers extends EnumStringBody {
+  +hasUnknownMembers: $NonMaybeType<EnumStringBody['hasUnknownMembers']>;
+}
+interface EnumStringMember_With_id extends EnumStringMember {
+  +id: $NonMaybeType<EnumStringMember['id']>;
+}
+interface EnumStringMember_With_init extends EnumStringMember {
+  +init: $NonMaybeType<EnumStringMember['init']>;
+}
+interface EnumSymbolBody_With_members extends EnumSymbolBody {
+  +members: $NonMaybeType<EnumSymbolBody['members']>;
+}
+interface EnumSymbolBody_With_hasUnknownMembers extends EnumSymbolBody {
+  +hasUnknownMembers: $NonMaybeType<EnumSymbolBody['hasUnknownMembers']>;
+}
+interface ExportAllDeclaration_With_source extends ExportAllDeclaration {
+  +source: $NonMaybeType<ExportAllDeclaration['source']>;
+}
+interface ExportAllDeclaration_With_exportKind extends ExportAllDeclaration {
+  +exportKind: $NonMaybeType<ExportAllDeclaration['exportKind']>;
+}
+interface ExportDefaultDeclaration_With_declaration
+  extends ExportDefaultDeclaration {
+  +declaration: $NonMaybeType<ExportDefaultDeclaration['declaration']>;
+}
+interface ExportNamedDeclaration_With_declaration
+  extends ExportNamedDeclaration {
+  +declaration: $NonMaybeType<ExportNamedDeclaration['declaration']>;
+}
+interface ExportNamedDeclaration_With_specifiers
+  extends ExportNamedDeclaration {
+  +specifiers: $NonMaybeType<ExportNamedDeclaration['specifiers']>;
+}
+interface ExportNamedDeclaration_With_source extends ExportNamedDeclaration {
+  +source: $NonMaybeType<ExportNamedDeclaration['source']>;
+}
+interface ExportNamedDeclaration_With_exportKind
+  extends ExportNamedDeclaration {
+  +exportKind: $NonMaybeType<ExportNamedDeclaration['exportKind']>;
+}
+interface ExportNamespaceSpecifier_With_exported
+  extends ExportNamespaceSpecifier {
+  +exported: $NonMaybeType<ExportNamespaceSpecifier['exported']>;
+}
+interface ExportSpecifier_With_exported extends ExportSpecifier {
+  +exported: $NonMaybeType<ExportSpecifier['exported']>;
+}
+interface ExportSpecifier_With_local extends ExportSpecifier {
+  +local: $NonMaybeType<ExportSpecifier['local']>;
+}
+interface ExpressionStatement_With_expression extends ExpressionStatement {
+  +expression: $NonMaybeType<ExpressionStatement['expression']>;
+}
+interface ExpressionStatement_With_directive extends ExpressionStatement {
+  +directive: $NonMaybeType<ExpressionStatement['directive']>;
+}
+interface ForInStatement_With_left extends ForInStatement {
+  +left: $NonMaybeType<ForInStatement['left']>;
+}
+interface ForInStatement_With_right extends ForInStatement {
+  +right: $NonMaybeType<ForInStatement['right']>;
+}
+interface ForInStatement_With_body extends ForInStatement {
+  +body: $NonMaybeType<ForInStatement['body']>;
+}
+interface ForOfStatement_With_left extends ForOfStatement {
+  +left: $NonMaybeType<ForOfStatement['left']>;
+}
+interface ForOfStatement_With_right extends ForOfStatement {
+  +right: $NonMaybeType<ForOfStatement['right']>;
+}
+interface ForOfStatement_With_body extends ForOfStatement {
+  +body: $NonMaybeType<ForOfStatement['body']>;
+}
+interface ForOfStatement_With_await extends ForOfStatement {
+  +await: $NonMaybeType<ForOfStatement['await']>;
+}
+interface ForStatement_With_init extends ForStatement {
+  +init: $NonMaybeType<ForStatement['init']>;
+}
+interface ForStatement_With_test extends ForStatement {
+  +test: $NonMaybeType<ForStatement['test']>;
+}
+interface ForStatement_With_update extends ForStatement {
+  +update: $NonMaybeType<ForStatement['update']>;
+}
+interface ForStatement_With_body extends ForStatement {
+  +body: $NonMaybeType<ForStatement['body']>;
+}
+interface FunctionDeclaration_With_id extends FunctionDeclaration {
+  +id: $NonMaybeType<FunctionDeclaration['id']>;
+}
+interface FunctionDeclaration_With_params extends FunctionDeclaration {
+  +params: $NonMaybeType<FunctionDeclaration['params']>;
+}
+interface FunctionDeclaration_With_body extends FunctionDeclaration {
+  +body: $NonMaybeType<FunctionDeclaration['body']>;
+}
+interface FunctionDeclaration_With_typeParameters extends FunctionDeclaration {
+  +typeParameters: $NonMaybeType<FunctionDeclaration['typeParameters']>;
+}
+interface FunctionDeclaration_With_returnType extends FunctionDeclaration {
+  +returnType: $NonMaybeType<FunctionDeclaration['returnType']>;
+}
+interface FunctionDeclaration_With_predicate extends FunctionDeclaration {
+  +predicate: $NonMaybeType<FunctionDeclaration['predicate']>;
+}
+interface FunctionDeclaration_With_generator extends FunctionDeclaration {
+  +generator: $NonMaybeType<FunctionDeclaration['generator']>;
+}
+interface FunctionDeclaration_With_async extends FunctionDeclaration {
+  +async: $NonMaybeType<FunctionDeclaration['async']>;
+}
+interface FunctionExpression_With_id extends FunctionExpression {
+  +id: $NonMaybeType<FunctionExpression['id']>;
+}
+interface FunctionExpression_With_params extends FunctionExpression {
+  +params: $NonMaybeType<FunctionExpression['params']>;
+}
+interface FunctionExpression_With_body extends FunctionExpression {
+  +body: $NonMaybeType<FunctionExpression['body']>;
+}
+interface FunctionExpression_With_typeParameters extends FunctionExpression {
+  +typeParameters: $NonMaybeType<FunctionExpression['typeParameters']>;
+}
+interface FunctionExpression_With_returnType extends FunctionExpression {
+  +returnType: $NonMaybeType<FunctionExpression['returnType']>;
+}
+interface FunctionExpression_With_predicate extends FunctionExpression {
+  +predicate: $NonMaybeType<FunctionExpression['predicate']>;
+}
+interface FunctionExpression_With_generator extends FunctionExpression {
+  +generator: $NonMaybeType<FunctionExpression['generator']>;
+}
+interface FunctionExpression_With_async extends FunctionExpression {
+  +async: $NonMaybeType<FunctionExpression['async']>;
+}
+interface FunctionTypeAnnotation_With_params extends FunctionTypeAnnotation {
+  +params: $NonMaybeType<FunctionTypeAnnotation['params']>;
+}
+interface FunctionTypeAnnotation_With_this extends FunctionTypeAnnotation {
+  +this: $NonMaybeType<FunctionTypeAnnotation['this']>;
+}
+interface FunctionTypeAnnotation_With_returnType
+  extends FunctionTypeAnnotation {
+  +returnType: $NonMaybeType<FunctionTypeAnnotation['returnType']>;
+}
+interface FunctionTypeAnnotation_With_rest extends FunctionTypeAnnotation {
+  +rest: $NonMaybeType<FunctionTypeAnnotation['rest']>;
+}
+interface FunctionTypeAnnotation_With_typeParameters
+  extends FunctionTypeAnnotation {
+  +typeParameters: $NonMaybeType<FunctionTypeAnnotation['typeParameters']>;
+}
+interface FunctionTypeParam_With_name extends FunctionTypeParam {
+  +name: $NonMaybeType<FunctionTypeParam['name']>;
+}
+interface FunctionTypeParam_With_typeAnnotation extends FunctionTypeParam {
+  +typeAnnotation: $NonMaybeType<FunctionTypeParam['typeAnnotation']>;
+}
+interface FunctionTypeParam_With_optional extends FunctionTypeParam {
+  +optional: $NonMaybeType<FunctionTypeParam['optional']>;
+}
+interface GenericTypeAnnotation_With_id extends GenericTypeAnnotation {
+  +id: $NonMaybeType<GenericTypeAnnotation['id']>;
+}
+interface GenericTypeAnnotation_With_typeParameters
+  extends GenericTypeAnnotation {
+  +typeParameters: $NonMaybeType<GenericTypeAnnotation['typeParameters']>;
+}
+interface Identifier_With_name extends Identifier {
+  +name: $NonMaybeType<Identifier['name']>;
+}
+interface Identifier_With_typeAnnotation extends Identifier {
+  +typeAnnotation: $NonMaybeType<Identifier['typeAnnotation']>;
+}
+interface Identifier_With_optional extends Identifier {
+  +optional: $NonMaybeType<Identifier['optional']>;
+}
+interface IfStatement_With_test extends IfStatement {
+  +test: $NonMaybeType<IfStatement['test']>;
+}
+interface IfStatement_With_consequent extends IfStatement {
+  +consequent: $NonMaybeType<IfStatement['consequent']>;
+}
+interface IfStatement_With_alternate extends IfStatement {
+  +alternate: $NonMaybeType<IfStatement['alternate']>;
+}
+interface ImportAttribute_With_key extends ImportAttribute {
+  +key: $NonMaybeType<ImportAttribute['key']>;
+}
+interface ImportAttribute_With_value extends ImportAttribute {
+  +value: $NonMaybeType<ImportAttribute['value']>;
+}
+interface ImportDeclaration_With_specifiers extends ImportDeclaration {
+  +specifiers: $NonMaybeType<ImportDeclaration['specifiers']>;
+}
+interface ImportDeclaration_With_source extends ImportDeclaration {
+  +source: $NonMaybeType<ImportDeclaration['source']>;
+}
+interface ImportDeclaration_With_assertions extends ImportDeclaration {
+  +assertions: $NonMaybeType<ImportDeclaration['assertions']>;
+}
+interface ImportDeclaration_With_importKind extends ImportDeclaration {
+  +importKind: $NonMaybeType<ImportDeclaration['importKind']>;
+}
+interface ImportDefaultSpecifier_With_local extends ImportDefaultSpecifier {
+  +local: $NonMaybeType<ImportDefaultSpecifier['local']>;
+}
+interface ImportExpression_With_source extends ImportExpression {
+  +source: $NonMaybeType<ImportExpression['source']>;
+}
+interface ImportExpression_With_attributes extends ImportExpression {
+  +attributes: $NonMaybeType<ImportExpression['attributes']>;
+}
+interface ImportNamespaceSpecifier_With_local extends ImportNamespaceSpecifier {
+  +local: $NonMaybeType<ImportNamespaceSpecifier['local']>;
+}
+interface ImportSpecifier_With_imported extends ImportSpecifier {
+  +imported: $NonMaybeType<ImportSpecifier['imported']>;
+}
+interface ImportSpecifier_With_local extends ImportSpecifier {
+  +local: $NonMaybeType<ImportSpecifier['local']>;
+}
+interface ImportSpecifier_With_importKind extends ImportSpecifier {
+  +importKind: $NonMaybeType<ImportSpecifier['importKind']>;
+}
+interface IndexedAccessType_With_objectType extends IndexedAccessType {
+  +objectType: $NonMaybeType<IndexedAccessType['objectType']>;
+}
+interface IndexedAccessType_With_indexType extends IndexedAccessType {
+  +indexType: $NonMaybeType<IndexedAccessType['indexType']>;
+}
+interface InterfaceDeclaration_With_id extends InterfaceDeclaration {
+  +id: $NonMaybeType<InterfaceDeclaration['id']>;
+}
+interface InterfaceDeclaration_With_typeParameters
+  extends InterfaceDeclaration {
+  +typeParameters: $NonMaybeType<InterfaceDeclaration['typeParameters']>;
+}
+interface InterfaceDeclaration_With_extends extends InterfaceDeclaration {
+  +extends: $NonMaybeType<InterfaceDeclaration['extends']>;
+}
+interface InterfaceDeclaration_With_body extends InterfaceDeclaration {
+  +body: $NonMaybeType<InterfaceDeclaration['body']>;
+}
+interface InterfaceExtends_With_id extends InterfaceExtends {
+  +id: $NonMaybeType<InterfaceExtends['id']>;
+}
+interface InterfaceExtends_With_typeParameters extends InterfaceExtends {
+  +typeParameters: $NonMaybeType<InterfaceExtends['typeParameters']>;
+}
+interface InterfaceTypeAnnotation_With_extends extends InterfaceTypeAnnotation {
+  +extends: $NonMaybeType<InterfaceTypeAnnotation['extends']>;
+}
+interface InterfaceTypeAnnotation_With_body extends InterfaceTypeAnnotation {
+  +body: $NonMaybeType<InterfaceTypeAnnotation['body']>;
+}
+interface IntersectionTypeAnnotation_With_types
+  extends IntersectionTypeAnnotation {
+  +types: $NonMaybeType<IntersectionTypeAnnotation['types']>;
+}
+interface JSXAttribute_With_name extends JSXAttribute {
+  +name: $NonMaybeType<JSXAttribute['name']>;
+}
+interface JSXAttribute_With_value extends JSXAttribute {
+  +value: $NonMaybeType<JSXAttribute['value']>;
+}
+interface JSXClosingElement_With_name extends JSXClosingElement {
+  +name: $NonMaybeType<JSXClosingElement['name']>;
+}
+interface JSXElement_With_openingElement extends JSXElement {
+  +openingElement: $NonMaybeType<JSXElement['openingElement']>;
+}
+interface JSXElement_With_children extends JSXElement {
+  +children: $NonMaybeType<JSXElement['children']>;
+}
+interface JSXElement_With_closingElement extends JSXElement {
+  +closingElement: $NonMaybeType<JSXElement['closingElement']>;
+}
+interface JSXExpressionContainer_With_expression
+  extends JSXExpressionContainer {
+  +expression: $NonMaybeType<JSXExpressionContainer['expression']>;
+}
+interface JSXFragment_With_openingFragment extends JSXFragment {
+  +openingFragment: $NonMaybeType<JSXFragment['openingFragment']>;
+}
+interface JSXFragment_With_children extends JSXFragment {
+  +children: $NonMaybeType<JSXFragment['children']>;
+}
+interface JSXFragment_With_closingFragment extends JSXFragment {
+  +closingFragment: $NonMaybeType<JSXFragment['closingFragment']>;
+}
+interface JSXIdentifier_With_name extends JSXIdentifier {
+  +name: $NonMaybeType<JSXIdentifier['name']>;
+}
+interface JSXMemberExpression_With_object extends JSXMemberExpression {
+  +object: $NonMaybeType<JSXMemberExpression['object']>;
+}
+interface JSXMemberExpression_With_property extends JSXMemberExpression {
+  +property: $NonMaybeType<JSXMemberExpression['property']>;
+}
+interface JSXNamespacedName_With_namespace extends JSXNamespacedName {
+  +namespace: $NonMaybeType<JSXNamespacedName['namespace']>;
+}
+interface JSXNamespacedName_With_name extends JSXNamespacedName {
+  +name: $NonMaybeType<JSXNamespacedName['name']>;
+}
+interface JSXOpeningElement_With_name extends JSXOpeningElement {
+  +name: $NonMaybeType<JSXOpeningElement['name']>;
+}
+interface JSXOpeningElement_With_attributes extends JSXOpeningElement {
+  +attributes: $NonMaybeType<JSXOpeningElement['attributes']>;
+}
+interface JSXOpeningElement_With_selfClosing extends JSXOpeningElement {
+  +selfClosing: $NonMaybeType<JSXOpeningElement['selfClosing']>;
+}
+interface JSXSpreadAttribute_With_argument extends JSXSpreadAttribute {
+  +argument: $NonMaybeType<JSXSpreadAttribute['argument']>;
+}
+interface JSXSpreadChild_With_expression extends JSXSpreadChild {
+  +expression: $NonMaybeType<JSXSpreadChild['expression']>;
+}
+interface JSXText_With_value extends JSXText {
+  +value: $NonMaybeType<JSXText['value']>;
+}
+interface JSXText_With_raw extends JSXText {
+  +raw: $NonMaybeType<JSXText['raw']>;
+}
+interface LabeledStatement_With_label extends LabeledStatement {
+  +label: $NonMaybeType<LabeledStatement['label']>;
+}
+interface LabeledStatement_With_body extends LabeledStatement {
+  +body: $NonMaybeType<LabeledStatement['body']>;
+}
+interface LogicalExpression_With_left extends LogicalExpression {
+  +left: $NonMaybeType<LogicalExpression['left']>;
+}
+interface LogicalExpression_With_right extends LogicalExpression {
+  +right: $NonMaybeType<LogicalExpression['right']>;
+}
+interface LogicalExpression_With_operator extends LogicalExpression {
+  +operator: $NonMaybeType<LogicalExpression['operator']>;
+}
+interface MemberExpression_With_object extends MemberExpression {
+  +object: $NonMaybeType<MemberExpression['object']>;
+}
+interface MemberExpression_With_property extends MemberExpression {
+  +property: $NonMaybeType<MemberExpression['property']>;
+}
+interface MemberExpression_With_computed extends MemberExpression {
+  +computed: $NonMaybeType<MemberExpression['computed']>;
+}
+interface MetaProperty_With_meta extends MetaProperty {
+  +meta: $NonMaybeType<MetaProperty['meta']>;
+}
+interface MetaProperty_With_property extends MetaProperty {
+  +property: $NonMaybeType<MetaProperty['property']>;
+}
+interface MethodDefinition_With_key extends MethodDefinition {
+  +key: $NonMaybeType<MethodDefinition['key']>;
+}
+interface MethodDefinition_With_value extends MethodDefinition {
+  +value: $NonMaybeType<MethodDefinition['value']>;
+}
+interface MethodDefinition_With_kind extends MethodDefinition {
+  +kind: $NonMaybeType<MethodDefinition['kind']>;
+}
+interface MethodDefinition_With_computed extends MethodDefinition {
+  +computed: $NonMaybeType<MethodDefinition['computed']>;
+}
+interface MethodDefinition_With_static extends MethodDefinition {
+  +static: $NonMaybeType<MethodDefinition['static']>;
+}
+interface NewExpression_With_callee extends NewExpression {
+  +callee: $NonMaybeType<NewExpression['callee']>;
+}
+interface NewExpression_With_typeArguments extends NewExpression {
+  +typeArguments: $NonMaybeType<NewExpression['typeArguments']>;
+}
+interface NewExpression_With_arguments extends NewExpression {
+  +arguments: $NonMaybeType<NewExpression['arguments']>;
+}
+interface NullableTypeAnnotation_With_typeAnnotation
+  extends NullableTypeAnnotation {
+  +typeAnnotation: $NonMaybeType<NullableTypeAnnotation['typeAnnotation']>;
+}
+interface NumberLiteralTypeAnnotation_With_value
+  extends NumberLiteralTypeAnnotation {
+  +value: $NonMaybeType<NumberLiteralTypeAnnotation['value']>;
+}
+interface NumberLiteralTypeAnnotation_With_raw
+  extends NumberLiteralTypeAnnotation {
+  +raw: $NonMaybeType<NumberLiteralTypeAnnotation['raw']>;
+}
+interface ObjectExpression_With_properties extends ObjectExpression {
+  +properties: $NonMaybeType<ObjectExpression['properties']>;
+}
+interface ObjectPattern_With_properties extends ObjectPattern {
+  +properties: $NonMaybeType<ObjectPattern['properties']>;
+}
+interface ObjectPattern_With_typeAnnotation extends ObjectPattern {
+  +typeAnnotation: $NonMaybeType<ObjectPattern['typeAnnotation']>;
+}
+interface ObjectTypeAnnotation_With_properties extends ObjectTypeAnnotation {
+  +properties: $NonMaybeType<ObjectTypeAnnotation['properties']>;
+}
+interface ObjectTypeAnnotation_With_indexers extends ObjectTypeAnnotation {
+  +indexers: $NonMaybeType<ObjectTypeAnnotation['indexers']>;
+}
+interface ObjectTypeAnnotation_With_callProperties
+  extends ObjectTypeAnnotation {
+  +callProperties: $NonMaybeType<ObjectTypeAnnotation['callProperties']>;
+}
+interface ObjectTypeAnnotation_With_internalSlots extends ObjectTypeAnnotation {
+  +internalSlots: $NonMaybeType<ObjectTypeAnnotation['internalSlots']>;
+}
+interface ObjectTypeAnnotation_With_inexact extends ObjectTypeAnnotation {
+  +inexact: $NonMaybeType<ObjectTypeAnnotation['inexact']>;
+}
+interface ObjectTypeAnnotation_With_exact extends ObjectTypeAnnotation {
+  +exact: $NonMaybeType<ObjectTypeAnnotation['exact']>;
+}
+interface ObjectTypeCallProperty_With_value extends ObjectTypeCallProperty {
+  +value: $NonMaybeType<ObjectTypeCallProperty['value']>;
+}
+interface ObjectTypeCallProperty_With_static extends ObjectTypeCallProperty {
+  +static: $NonMaybeType<ObjectTypeCallProperty['static']>;
+}
+interface ObjectTypeIndexer_With_id extends ObjectTypeIndexer {
+  +id: $NonMaybeType<ObjectTypeIndexer['id']>;
+}
+interface ObjectTypeIndexer_With_key extends ObjectTypeIndexer {
+  +key: $NonMaybeType<ObjectTypeIndexer['key']>;
+}
+interface ObjectTypeIndexer_With_value extends ObjectTypeIndexer {
+  +value: $NonMaybeType<ObjectTypeIndexer['value']>;
+}
+interface ObjectTypeIndexer_With_static extends ObjectTypeIndexer {
+  +static: $NonMaybeType<ObjectTypeIndexer['static']>;
+}
+interface ObjectTypeIndexer_With_variance extends ObjectTypeIndexer {
+  +variance: $NonMaybeType<ObjectTypeIndexer['variance']>;
+}
+interface ObjectTypeInternalSlot_With_id extends ObjectTypeInternalSlot {
+  +id: $NonMaybeType<ObjectTypeInternalSlot['id']>;
+}
+interface ObjectTypeInternalSlot_With_value extends ObjectTypeInternalSlot {
+  +value: $NonMaybeType<ObjectTypeInternalSlot['value']>;
+}
+interface ObjectTypeInternalSlot_With_optional extends ObjectTypeInternalSlot {
+  +optional: $NonMaybeType<ObjectTypeInternalSlot['optional']>;
+}
+interface ObjectTypeInternalSlot_With_static extends ObjectTypeInternalSlot {
+  +static: $NonMaybeType<ObjectTypeInternalSlot['static']>;
+}
+interface ObjectTypeInternalSlot_With_method extends ObjectTypeInternalSlot {
+  +method: $NonMaybeType<ObjectTypeInternalSlot['method']>;
+}
+interface ObjectTypeProperty_With_key extends ObjectTypeProperty {
+  +key: $NonMaybeType<ObjectTypeProperty['key']>;
+}
+interface ObjectTypeProperty_With_value extends ObjectTypeProperty {
+  +value: $NonMaybeType<ObjectTypeProperty['value']>;
+}
+interface ObjectTypeProperty_With_method extends ObjectTypeProperty {
+  +method: $NonMaybeType<ObjectTypeProperty['method']>;
+}
+interface ObjectTypeProperty_With_optional extends ObjectTypeProperty {
+  +optional: $NonMaybeType<ObjectTypeProperty['optional']>;
+}
+interface ObjectTypeProperty_With_static extends ObjectTypeProperty {
+  +static: $NonMaybeType<ObjectTypeProperty['static']>;
+}
+interface ObjectTypeProperty_With_proto extends ObjectTypeProperty {
+  +proto: $NonMaybeType<ObjectTypeProperty['proto']>;
+}
+interface ObjectTypeProperty_With_variance extends ObjectTypeProperty {
+  +variance: $NonMaybeType<ObjectTypeProperty['variance']>;
+}
+interface ObjectTypeProperty_With_kind extends ObjectTypeProperty {
+  +kind: $NonMaybeType<ObjectTypeProperty['kind']>;
+}
+interface ObjectTypeSpreadProperty_With_argument
+  extends ObjectTypeSpreadProperty {
+  +argument: $NonMaybeType<ObjectTypeSpreadProperty['argument']>;
+}
+interface OpaqueType_With_id extends OpaqueType {
+  +id: $NonMaybeType<OpaqueType['id']>;
+}
+interface OpaqueType_With_typeParameters extends OpaqueType {
+  +typeParameters: $NonMaybeType<OpaqueType['typeParameters']>;
+}
+interface OpaqueType_With_impltype extends OpaqueType {
+  +impltype: $NonMaybeType<OpaqueType['impltype']>;
+}
+interface OpaqueType_With_supertype extends OpaqueType {
+  +supertype: $NonMaybeType<OpaqueType['supertype']>;
+}
+interface OptionalCallExpression_With_callee extends OptionalCallExpression {
+  +callee: $NonMaybeType<OptionalCallExpression['callee']>;
+}
+interface OptionalCallExpression_With_typeArguments
+  extends OptionalCallExpression {
+  +typeArguments: $NonMaybeType<OptionalCallExpression['typeArguments']>;
+}
+interface OptionalCallExpression_With_arguments extends OptionalCallExpression {
+  +arguments: $NonMaybeType<OptionalCallExpression['arguments']>;
+}
+interface OptionalCallExpression_With_optional extends OptionalCallExpression {
+  +optional: $NonMaybeType<OptionalCallExpression['optional']>;
+}
+interface OptionalIndexedAccessType_With_objectType
+  extends OptionalIndexedAccessType {
+  +objectType: $NonMaybeType<OptionalIndexedAccessType['objectType']>;
+}
+interface OptionalIndexedAccessType_With_indexType
+  extends OptionalIndexedAccessType {
+  +indexType: $NonMaybeType<OptionalIndexedAccessType['indexType']>;
+}
+interface OptionalIndexedAccessType_With_optional
+  extends OptionalIndexedAccessType {
+  +optional: $NonMaybeType<OptionalIndexedAccessType['optional']>;
+}
+interface OptionalMemberExpression_With_object
+  extends OptionalMemberExpression {
+  +object: $NonMaybeType<OptionalMemberExpression['object']>;
+}
+interface OptionalMemberExpression_With_property
+  extends OptionalMemberExpression {
+  +property: $NonMaybeType<OptionalMemberExpression['property']>;
+}
+interface OptionalMemberExpression_With_computed
+  extends OptionalMemberExpression {
+  +computed: $NonMaybeType<OptionalMemberExpression['computed']>;
+}
+interface OptionalMemberExpression_With_optional
+  extends OptionalMemberExpression {
+  +optional: $NonMaybeType<OptionalMemberExpression['optional']>;
+}
+interface PrivateName_With_id extends PrivateName {
+  +id: $NonMaybeType<PrivateName['id']>;
+}
+interface Program_With_body extends Program {
+  +body: $NonMaybeType<Program['body']>;
+}
+interface Property_With_key extends Property {
+  +key: $NonMaybeType<Property['key']>;
+}
+interface Property_With_value extends Property {
+  +value: $NonMaybeType<Property['value']>;
+}
+interface Property_With_kind extends Property {
+  +kind: $NonMaybeType<Property['kind']>;
+}
+interface Property_With_computed extends Property {
+  +computed: $NonMaybeType<Property['computed']>;
+}
+interface Property_With_method extends Property {
+  +method: $NonMaybeType<Property['method']>;
+}
+interface Property_With_shorthand extends Property {
+  +shorthand: $NonMaybeType<Property['shorthand']>;
+}
+interface QualifiedTypeIdentifier_With_qualification
+  extends QualifiedTypeIdentifier {
+  +qualification: $NonMaybeType<QualifiedTypeIdentifier['qualification']>;
+}
+interface QualifiedTypeIdentifier_With_id extends QualifiedTypeIdentifier {
+  +id: $NonMaybeType<QualifiedTypeIdentifier['id']>;
+}
+interface RestElement_With_argument extends RestElement {
+  +argument: $NonMaybeType<RestElement['argument']>;
+}
+interface ReturnStatement_With_argument extends ReturnStatement {
+  +argument: $NonMaybeType<ReturnStatement['argument']>;
+}
+interface SequenceExpression_With_expressions extends SequenceExpression {
+  +expressions: $NonMaybeType<SequenceExpression['expressions']>;
+}
+interface SpreadElement_With_argument extends SpreadElement {
+  +argument: $NonMaybeType<SpreadElement['argument']>;
+}
+interface StringLiteralTypeAnnotation_With_value
+  extends StringLiteralTypeAnnotation {
+  +value: $NonMaybeType<StringLiteralTypeAnnotation['value']>;
+}
+interface SwitchCase_With_test extends SwitchCase {
+  +test: $NonMaybeType<SwitchCase['test']>;
+}
+interface SwitchCase_With_consequent extends SwitchCase {
+  +consequent: $NonMaybeType<SwitchCase['consequent']>;
+}
+interface SwitchStatement_With_discriminant extends SwitchStatement {
+  +discriminant: $NonMaybeType<SwitchStatement['discriminant']>;
+}
+interface SwitchStatement_With_cases extends SwitchStatement {
+  +cases: $NonMaybeType<SwitchStatement['cases']>;
+}
+interface TaggedTemplateExpression_With_tag extends TaggedTemplateExpression {
+  +tag: $NonMaybeType<TaggedTemplateExpression['tag']>;
+}
+interface TaggedTemplateExpression_With_quasi extends TaggedTemplateExpression {
+  +quasi: $NonMaybeType<TaggedTemplateExpression['quasi']>;
+}
+interface TemplateElement_With_tail extends TemplateElement {
+  +tail: $NonMaybeType<TemplateElement['tail']>;
+}
+interface TemplateElement_With_cooked extends TemplateElement {
+  +cooked: $NonMaybeType<TemplateElement['cooked']>;
+}
+interface TemplateElement_With_raw extends TemplateElement {
+  +raw: $NonMaybeType<TemplateElement['raw']>;
+}
+interface TemplateLiteral_With_quasis extends TemplateLiteral {
+  +quasis: $NonMaybeType<TemplateLiteral['quasis']>;
+}
+interface TemplateLiteral_With_expressions extends TemplateLiteral {
+  +expressions: $NonMaybeType<TemplateLiteral['expressions']>;
+}
+interface ThrowStatement_With_argument extends ThrowStatement {
+  +argument: $NonMaybeType<ThrowStatement['argument']>;
+}
+interface TryStatement_With_block extends TryStatement {
+  +block: $NonMaybeType<TryStatement['block']>;
+}
+interface TryStatement_With_handler extends TryStatement {
+  +handler: $NonMaybeType<TryStatement['handler']>;
+}
+interface TryStatement_With_finalizer extends TryStatement {
+  +finalizer: $NonMaybeType<TryStatement['finalizer']>;
+}
+interface TupleTypeAnnotation_With_types extends TupleTypeAnnotation {
+  +types: $NonMaybeType<TupleTypeAnnotation['types']>;
+}
+interface TypeAlias_With_id extends TypeAlias {
+  +id: $NonMaybeType<TypeAlias['id']>;
+}
+interface TypeAlias_With_typeParameters extends TypeAlias {
+  +typeParameters: $NonMaybeType<TypeAlias['typeParameters']>;
+}
+interface TypeAlias_With_right extends TypeAlias {
+  +right: $NonMaybeType<TypeAlias['right']>;
+}
+interface TypeAnnotation_With_typeAnnotation extends TypeAnnotation {
+  +typeAnnotation: $NonMaybeType<TypeAnnotation['typeAnnotation']>;
+}
+interface TypeCastExpression_With_expression extends TypeCastExpression {
+  +expression: $NonMaybeType<TypeCastExpression['expression']>;
+}
+interface TypeCastExpression_With_typeAnnotation extends TypeCastExpression {
+  +typeAnnotation: $NonMaybeType<TypeCastExpression['typeAnnotation']>;
+}
+interface TypeofTypeAnnotation_With_argument extends TypeofTypeAnnotation {
+  +argument: $NonMaybeType<TypeofTypeAnnotation['argument']>;
+}
+interface TypeParameter_With_name extends TypeParameter {
+  +name: $NonMaybeType<TypeParameter['name']>;
+}
+interface TypeParameter_With_bound extends TypeParameter {
+  +bound: $NonMaybeType<TypeParameter['bound']>;
+}
+interface TypeParameter_With_variance extends TypeParameter {
+  +variance: $NonMaybeType<TypeParameter['variance']>;
+}
+interface TypeParameter_With_default extends TypeParameter {
+  +default: $NonMaybeType<TypeParameter['default']>;
+}
+interface TypeParameterDeclaration_With_params
+  extends TypeParameterDeclaration {
+  +params: $NonMaybeType<TypeParameterDeclaration['params']>;
+}
+interface TypeParameterInstantiation_With_params
+  extends TypeParameterInstantiation {
+  +params: $NonMaybeType<TypeParameterInstantiation['params']>;
+}
+interface UnaryExpression_With_operator extends UnaryExpression {
+  +operator: $NonMaybeType<UnaryExpression['operator']>;
+}
+interface UnaryExpression_With_argument extends UnaryExpression {
+  +argument: $NonMaybeType<UnaryExpression['argument']>;
+}
+interface UnaryExpression_With_prefix extends UnaryExpression {
+  +prefix: $NonMaybeType<UnaryExpression['prefix']>;
+}
+interface UnionTypeAnnotation_With_types extends UnionTypeAnnotation {
+  +types: $NonMaybeType<UnionTypeAnnotation['types']>;
+}
+interface UpdateExpression_With_operator extends UpdateExpression {
+  +operator: $NonMaybeType<UpdateExpression['operator']>;
+}
+interface UpdateExpression_With_argument extends UpdateExpression {
+  +argument: $NonMaybeType<UpdateExpression['argument']>;
+}
+interface UpdateExpression_With_prefix extends UpdateExpression {
+  +prefix: $NonMaybeType<UpdateExpression['prefix']>;
+}
+interface VariableDeclaration_With_kind extends VariableDeclaration {
+  +kind: $NonMaybeType<VariableDeclaration['kind']>;
+}
+interface VariableDeclaration_With_declarations extends VariableDeclaration {
+  +declarations: $NonMaybeType<VariableDeclaration['declarations']>;
+}
+interface VariableDeclarator_With_init extends VariableDeclarator {
+  +init: $NonMaybeType<VariableDeclarator['init']>;
+}
+interface VariableDeclarator_With_id extends VariableDeclarator {
+  +id: $NonMaybeType<VariableDeclarator['id']>;
+}
+interface Variance_With_kind extends Variance {
+  +kind: $NonMaybeType<Variance['kind']>;
+}
+interface WhileStatement_With_body extends WhileStatement {
+  +body: $NonMaybeType<WhileStatement['body']>;
+}
+interface WhileStatement_With_test extends WhileStatement {
+  +test: $NonMaybeType<WhileStatement['test']>;
+}
+interface WithStatement_With_object extends WithStatement {
+  +object: $NonMaybeType<WithStatement['object']>;
+}
+interface WithStatement_With_body extends WithStatement {
+  +body: $NonMaybeType<WithStatement['body']>;
+}
+interface YieldExpression_With_argument extends YieldExpression {
+  +argument: $NonMaybeType<YieldExpression['argument']>;
+}
+interface YieldExpression_With_delegate extends YieldExpression {
+  +delegate: $NonMaybeType<YieldExpression['delegate']>;
+}
+type StarSpecialSelector = ESNode;
+type StatementSpecialSelector =
+  | BlockStatement
+  | BreakStatement
+  | ContinueStatement
+  | DebuggerStatement
+  | DoWhileStatement
+  | EmptyStatement
+  | ExpressionStatement
+  | ForInStatement
+  | ForOfStatement
+  | ForStatement
+  | IfStatement
+  | LabeledStatement
+  | ReturnStatement
+  | SwitchStatement
+  | ThrowStatement
+  | TryStatement
+  | WhileStatement
+  | WithStatement;
+type DeclarationSpecialSelector =
+  | ClassDeclaration
+  | DeclareExportAllDeclaration
+  | DeclareExportDeclaration
+  | EnumDeclaration
+  | ExportAllDeclaration
+  | ExportDefaultDeclaration
+  | ExportNamedDeclaration
+  | FunctionDeclaration
+  | ImportDeclaration
+  | InterfaceDeclaration
+  | TypeParameterDeclaration
+  | VariableDeclaration;
+type PatternSpecialSelector = ArrayPattern | AssignmentPattern | ObjectPattern;
+type ExpressionSpecialSelector =
+  | Identifier
+  | MetaProperty
+  | ArrayExpression
+  | ArrowFunctionExpression
+  | AssignmentExpression
+  | AwaitExpression
+  | BinaryExpression
+  | CallExpression
+  | ClassExpression
+  | ConditionalExpression
+  | FunctionExpression
+  | ImportExpression
+  | JSXEmptyExpression
+  | JSXMemberExpression
+  | LogicalExpression
+  | MemberExpression
+  | NewExpression
+  | ObjectExpression
+  | OptionalCallExpression
+  | OptionalMemberExpression
+  | SequenceExpression
+  | TaggedTemplateExpression
+  | ThisExpression
+  | TypeCastExpression
+  | UnaryExpression
+  | UpdateExpression
+  | YieldExpression
+  | TemplateLiteral;
+type FunctionSpecialSelector =
+  | FunctionDeclaration
+  | FunctionExpression
+  | ArrowFunctionExpression;
+
+export type ESQueryNodeSelectorsWithoutFallback = {
+  +AnyTypeAnnotation?: (node: AnyTypeAnnotation) => void,
+  +ArrayExpression?: (node: ArrayExpression) => void,
+  +'ArrayExpression[elements]'?: (node: ArrayExpression_With_elements) => void,
+  +'ArrayExpression[trailingComma]'?: (
+    node: ArrayExpression_With_trailingComma,
+  ) => void,
+  +ArrayPattern?: (node: ArrayPattern) => void,
+  +'ArrayPattern[elements]'?: (node: ArrayPattern_With_elements) => void,
+  +'ArrayPattern[typeAnnotation]'?: (
+    node: ArrayPattern_With_typeAnnotation,
+  ) => void,
+  +ArrayTypeAnnotation?: (node: ArrayTypeAnnotation) => void,
+  +'ArrayTypeAnnotation[elementType]'?: (
+    node: ArrayTypeAnnotation_With_elementType,
+  ) => void,
+  +ArrowFunctionExpression?: (node: ArrowFunctionExpression) => void,
+  +'ArrowFunctionExpression[id]'?: (
+    node: ArrowFunctionExpression_With_id,
+  ) => void,
+  +'ArrowFunctionExpression[params]'?: (
+    node: ArrowFunctionExpression_With_params,
+  ) => void,
+  +'ArrowFunctionExpression[body]'?: (
+    node: ArrowFunctionExpression_With_body,
+  ) => void,
+  +'ArrowFunctionExpression[typeParameters]'?: (
+    node: ArrowFunctionExpression_With_typeParameters,
+  ) => void,
+  +'ArrowFunctionExpression[returnType]'?: (
+    node: ArrowFunctionExpression_With_returnType,
+  ) => void,
+  +'ArrowFunctionExpression[predicate]'?: (
+    node: ArrowFunctionExpression_With_predicate,
+  ) => void,
+  +'ArrowFunctionExpression[expression]'?: (
+    node: ArrowFunctionExpression_With_expression,
+  ) => void,
+  +'ArrowFunctionExpression[async]'?: (
+    node: ArrowFunctionExpression_With_async,
+  ) => void,
+  +AssignmentExpression?: (node: AssignmentExpression) => void,
+  +'AssignmentExpression[operator]'?: (
+    node: AssignmentExpression_With_operator,
+  ) => void,
+  +'AssignmentExpression[left]'?: (
+    node: AssignmentExpression_With_left,
+  ) => void,
+  +'AssignmentExpression[right]'?: (
+    node: AssignmentExpression_With_right,
+  ) => void,
+  +AssignmentPattern?: (node: AssignmentPattern) => void,
+  +'AssignmentPattern[left]'?: (node: AssignmentPattern_With_left) => void,
+  +'AssignmentPattern[right]'?: (node: AssignmentPattern_With_right) => void,
+  +AwaitExpression?: (node: AwaitExpression) => void,
+  +'AwaitExpression[argument]'?: (node: AwaitExpression_With_argument) => void,
+  +BinaryExpression?: (node: BinaryExpression) => void,
+  +'BinaryExpression[left]'?: (node: BinaryExpression_With_left) => void,
+  +'BinaryExpression[right]'?: (node: BinaryExpression_With_right) => void,
+  +'BinaryExpression[operator]'?: (
+    node: BinaryExpression_With_operator,
+  ) => void,
+  +BlockStatement?: (node: BlockStatement) => void,
+  +'BlockStatement[body]'?: (node: BlockStatement_With_body) => void,
+  +BooleanLiteralTypeAnnotation?: (node: BooleanLiteralTypeAnnotation) => void,
+  +'BooleanLiteralTypeAnnotation[value]'?: (
+    node: BooleanLiteralTypeAnnotation_With_value,
+  ) => void,
+  +'BooleanLiteralTypeAnnotation[raw]'?: (
+    node: BooleanLiteralTypeAnnotation_With_raw,
+  ) => void,
+  +BooleanTypeAnnotation?: (node: BooleanTypeAnnotation) => void,
+  +BreakStatement?: (node: BreakStatement) => void,
+  +'BreakStatement[label]'?: (node: BreakStatement_With_label) => void,
+  +CallExpression?: (node: CallExpression) => void,
+  +'CallExpression[callee]'?: (node: CallExpression_With_callee) => void,
+  +'CallExpression[typeArguments]'?: (
+    node: CallExpression_With_typeArguments,
+  ) => void,
+  +'CallExpression[arguments]'?: (node: CallExpression_With_arguments) => void,
+  +CatchClause?: (node: CatchClause) => void,
+  +'CatchClause[param]'?: (node: CatchClause_With_param) => void,
+  +'CatchClause[body]'?: (node: CatchClause_With_body) => void,
+  +ClassBody?: (node: ClassBody) => void,
+  +'ClassBody[body]'?: (node: ClassBody_With_body) => void,
+  +ClassDeclaration?: (node: ClassDeclaration) => void,
+  +'ClassDeclaration[id]'?: (node: ClassDeclaration_With_id) => void,
+  +'ClassDeclaration[typeParameters]'?: (
+    node: ClassDeclaration_With_typeParameters,
+  ) => void,
+  +'ClassDeclaration[superClass]'?: (
+    node: ClassDeclaration_With_superClass,
+  ) => void,
+  +'ClassDeclaration[superTypeParameters]'?: (
+    node: ClassDeclaration_With_superTypeParameters,
+  ) => void,
+  +'ClassDeclaration[implements]'?: (
+    node: ClassDeclaration_With_implements,
+  ) => void,
+  +'ClassDeclaration[decorators]'?: (
+    node: ClassDeclaration_With_decorators,
+  ) => void,
+  +'ClassDeclaration[body]'?: (node: ClassDeclaration_With_body) => void,
+  +ClassExpression?: (node: ClassExpression) => void,
+  +'ClassExpression[id]'?: (node: ClassExpression_With_id) => void,
+  +'ClassExpression[typeParameters]'?: (
+    node: ClassExpression_With_typeParameters,
+  ) => void,
+  +'ClassExpression[superClass]'?: (
+    node: ClassExpression_With_superClass,
+  ) => void,
+  +'ClassExpression[superTypeParameters]'?: (
+    node: ClassExpression_With_superTypeParameters,
+  ) => void,
+  +'ClassExpression[implements]'?: (
+    node: ClassExpression_With_implements,
+  ) => void,
+  +'ClassExpression[decorators]'?: (
+    node: ClassExpression_With_decorators,
+  ) => void,
+  +'ClassExpression[body]'?: (node: ClassExpression_With_body) => void,
+  +ClassImplements?: (node: ClassImplements) => void,
+  +'ClassImplements[id]'?: (node: ClassImplements_With_id) => void,
+  +'ClassImplements[typeParameters]'?: (
+    node: ClassImplements_With_typeParameters,
+  ) => void,
+  +ClassPrivateProperty?: (node: ClassPrivateProperty) => void,
+  +'ClassPrivateProperty[key]'?: (node: ClassPrivateProperty_With_key) => void,
+  +'ClassPrivateProperty[value]'?: (
+    node: ClassPrivateProperty_With_value,
+  ) => void,
+  +'ClassPrivateProperty[static]'?: (
+    node: ClassPrivateProperty_With_static,
+  ) => void,
+  +'ClassPrivateProperty[declare]'?: (
+    node: ClassPrivateProperty_With_declare,
+  ) => void,
+  +'ClassPrivateProperty[optional]'?: (
+    node: ClassPrivateProperty_With_optional,
+  ) => void,
+  +'ClassPrivateProperty[variance]'?: (
+    node: ClassPrivateProperty_With_variance,
+  ) => void,
+  +'ClassPrivateProperty[typeAnnotation]'?: (
+    node: ClassPrivateProperty_With_typeAnnotation,
+  ) => void,
+  +ClassProperty?: (node: ClassProperty) => void,
+  +'ClassProperty[key]'?: (node: ClassProperty_With_key) => void,
+  +'ClassProperty[value]'?: (node: ClassProperty_With_value) => void,
+  +'ClassProperty[computed]'?: (node: ClassProperty_With_computed) => void,
+  +'ClassProperty[static]'?: (node: ClassProperty_With_static) => void,
+  +'ClassProperty[declare]'?: (node: ClassProperty_With_declare) => void,
+  +'ClassProperty[optional]'?: (node: ClassProperty_With_optional) => void,
+  +'ClassProperty[variance]'?: (node: ClassProperty_With_variance) => void,
+  +'ClassProperty[typeAnnotation]'?: (
+    node: ClassProperty_With_typeAnnotation,
+  ) => void,
+  +ConditionalExpression?: (node: ConditionalExpression) => void,
+  +'ConditionalExpression[test]'?: (
+    node: ConditionalExpression_With_test,
+  ) => void,
+  +'ConditionalExpression[alternate]'?: (
+    node: ConditionalExpression_With_alternate,
+  ) => void,
+  +'ConditionalExpression[consequent]'?: (
+    node: ConditionalExpression_With_consequent,
+  ) => void,
+  +ContinueStatement?: (node: ContinueStatement) => void,
+  +'ContinueStatement[label]'?: (node: ContinueStatement_With_label) => void,
+  +DebuggerStatement?: (node: DebuggerStatement) => void,
+  +DeclareClass?: (node: DeclareClass) => void,
+  +'DeclareClass[id]'?: (node: DeclareClass_With_id) => void,
+  +'DeclareClass[typeParameters]'?: (
+    node: DeclareClass_With_typeParameters,
+  ) => void,
+  +'DeclareClass[extends]'?: (node: DeclareClass_With_extends) => void,
+  +'DeclareClass[implements]'?: (node: DeclareClass_With_implements) => void,
+  +'DeclareClass[mixins]'?: (node: DeclareClass_With_mixins) => void,
+  +'DeclareClass[body]'?: (node: DeclareClass_With_body) => void,
+  +DeclaredPredicate?: (node: DeclaredPredicate) => void,
+  +'DeclaredPredicate[value]'?: (node: DeclaredPredicate_With_value) => void,
+  +DeclareExportAllDeclaration?: (node: DeclareExportAllDeclaration) => void,
+  +'DeclareExportAllDeclaration[source]'?: (
+    node: DeclareExportAllDeclaration_With_source,
+  ) => void,
+  +DeclareExportDeclaration?: (node: DeclareExportDeclaration) => void,
+  +'DeclareExportDeclaration[declaration]'?: (
+    node: DeclareExportDeclaration_With_declaration,
+  ) => void,
+  +'DeclareExportDeclaration[specifiers]'?: (
+    node: DeclareExportDeclaration_With_specifiers,
+  ) => void,
+  +'DeclareExportDeclaration[source]'?: (
+    node: DeclareExportDeclaration_With_source,
+  ) => void,
+  +'DeclareExportDeclaration[default]'?: (
+    node: DeclareExportDeclaration_With_default,
+  ) => void,
+  +DeclareFunction?: (node: DeclareFunction) => void,
+  +'DeclareFunction[id]'?: (node: DeclareFunction_With_id) => void,
+  +'DeclareFunction[predicate]'?: (
+    node: DeclareFunction_With_predicate,
+  ) => void,
+  +DeclareInterface?: (node: DeclareInterface) => void,
+  +'DeclareInterface[id]'?: (node: DeclareInterface_With_id) => void,
+  +'DeclareInterface[typeParameters]'?: (
+    node: DeclareInterface_With_typeParameters,
+  ) => void,
+  +'DeclareInterface[extends]'?: (node: DeclareInterface_With_extends) => void,
+  +'DeclareInterface[body]'?: (node: DeclareInterface_With_body) => void,
+  +DeclareModule?: (node: DeclareModule) => void,
+  +'DeclareModule[id]'?: (node: DeclareModule_With_id) => void,
+  +'DeclareModule[body]'?: (node: DeclareModule_With_body) => void,
+  +'DeclareModule[kind]'?: (node: DeclareModule_With_kind) => void,
+  +DeclareModuleExports?: (node: DeclareModuleExports) => void,
+  +'DeclareModuleExports[typeAnnotation]'?: (
+    node: DeclareModuleExports_With_typeAnnotation,
+  ) => void,
+  +DeclareOpaqueType?: (node: DeclareOpaqueType) => void,
+  +'DeclareOpaqueType[id]'?: (node: DeclareOpaqueType_With_id) => void,
+  +'DeclareOpaqueType[typeParameters]'?: (
+    node: DeclareOpaqueType_With_typeParameters,
+  ) => void,
+  +'DeclareOpaqueType[impltype]'?: (
+    node: DeclareOpaqueType_With_impltype,
+  ) => void,
+  +'DeclareOpaqueType[supertype]'?: (
+    node: DeclareOpaqueType_With_supertype,
+  ) => void,
+  +DeclareTypeAlias?: (node: DeclareTypeAlias) => void,
+  +'DeclareTypeAlias[id]'?: (node: DeclareTypeAlias_With_id) => void,
+  +'DeclareTypeAlias[typeParameters]'?: (
+    node: DeclareTypeAlias_With_typeParameters,
+  ) => void,
+  +'DeclareTypeAlias[right]'?: (node: DeclareTypeAlias_With_right) => void,
+  +DeclareVariable?: (node: DeclareVariable) => void,
+  +'DeclareVariable[id]'?: (node: DeclareVariable_With_id) => void,
+  +DoWhileStatement?: (node: DoWhileStatement) => void,
+  +'DoWhileStatement[body]'?: (node: DoWhileStatement_With_body) => void,
+  +'DoWhileStatement[test]'?: (node: DoWhileStatement_With_test) => void,
+  +EmptyStatement?: (node: EmptyStatement) => void,
+  +EmptyTypeAnnotation?: (node: EmptyTypeAnnotation) => void,
+  +EnumBooleanBody?: (node: EnumBooleanBody) => void,
+  +'EnumBooleanBody[members]'?: (node: EnumBooleanBody_With_members) => void,
+  +'EnumBooleanBody[explicitType]'?: (
+    node: EnumBooleanBody_With_explicitType,
+  ) => void,
+  +'EnumBooleanBody[hasUnknownMembers]'?: (
+    node: EnumBooleanBody_With_hasUnknownMembers,
+  ) => void,
+  +EnumBooleanMember?: (node: EnumBooleanMember) => void,
+  +'EnumBooleanMember[id]'?: (node: EnumBooleanMember_With_id) => void,
+  +'EnumBooleanMember[init]'?: (node: EnumBooleanMember_With_init) => void,
+  +EnumDeclaration?: (node: EnumDeclaration) => void,
+  +'EnumDeclaration[id]'?: (node: EnumDeclaration_With_id) => void,
+  +'EnumDeclaration[body]'?: (node: EnumDeclaration_With_body) => void,
+  +EnumDefaultedMember?: (node: EnumDefaultedMember) => void,
+  +'EnumDefaultedMember[id]'?: (node: EnumDefaultedMember_With_id) => void,
+  +EnumNumberBody?: (node: EnumNumberBody) => void,
+  +'EnumNumberBody[members]'?: (node: EnumNumberBody_With_members) => void,
+  +'EnumNumberBody[explicitType]'?: (
+    node: EnumNumberBody_With_explicitType,
+  ) => void,
+  +'EnumNumberBody[hasUnknownMembers]'?: (
+    node: EnumNumberBody_With_hasUnknownMembers,
+  ) => void,
+  +EnumNumberMember?: (node: EnumNumberMember) => void,
+  +'EnumNumberMember[id]'?: (node: EnumNumberMember_With_id) => void,
+  +'EnumNumberMember[init]'?: (node: EnumNumberMember_With_init) => void,
+  +EnumStringBody?: (node: EnumStringBody) => void,
+  +'EnumStringBody[members]'?: (node: EnumStringBody_With_members) => void,
+  +'EnumStringBody[explicitType]'?: (
+    node: EnumStringBody_With_explicitType,
+  ) => void,
+  +'EnumStringBody[hasUnknownMembers]'?: (
+    node: EnumStringBody_With_hasUnknownMembers,
+  ) => void,
+  +EnumStringMember?: (node: EnumStringMember) => void,
+  +'EnumStringMember[id]'?: (node: EnumStringMember_With_id) => void,
+  +'EnumStringMember[init]'?: (node: EnumStringMember_With_init) => void,
+  +EnumSymbolBody?: (node: EnumSymbolBody) => void,
+  +'EnumSymbolBody[members]'?: (node: EnumSymbolBody_With_members) => void,
+  +'EnumSymbolBody[hasUnknownMembers]'?: (
+    node: EnumSymbolBody_With_hasUnknownMembers,
+  ) => void,
+  +ExistsTypeAnnotation?: (node: ExistsTypeAnnotation) => void,
+  +ExportAllDeclaration?: (node: ExportAllDeclaration) => void,
+  +'ExportAllDeclaration[source]'?: (
+    node: ExportAllDeclaration_With_source,
+  ) => void,
+  +'ExportAllDeclaration[exportKind]'?: (
+    node: ExportAllDeclaration_With_exportKind,
+  ) => void,
+  +ExportDefaultDeclaration?: (node: ExportDefaultDeclaration) => void,
+  +'ExportDefaultDeclaration[declaration]'?: (
+    node: ExportDefaultDeclaration_With_declaration,
+  ) => void,
+  +ExportNamedDeclaration?: (node: ExportNamedDeclaration) => void,
+  +'ExportNamedDeclaration[declaration]'?: (
+    node: ExportNamedDeclaration_With_declaration,
+  ) => void,
+  +'ExportNamedDeclaration[specifiers]'?: (
+    node: ExportNamedDeclaration_With_specifiers,
+  ) => void,
+  +'ExportNamedDeclaration[source]'?: (
+    node: ExportNamedDeclaration_With_source,
+  ) => void,
+  +'ExportNamedDeclaration[exportKind]'?: (
+    node: ExportNamedDeclaration_With_exportKind,
+  ) => void,
+  +ExportNamespaceSpecifier?: (node: ExportNamespaceSpecifier) => void,
+  +'ExportNamespaceSpecifier[exported]'?: (
+    node: ExportNamespaceSpecifier_With_exported,
+  ) => void,
+  +ExportSpecifier?: (node: ExportSpecifier) => void,
+  +'ExportSpecifier[exported]'?: (node: ExportSpecifier_With_exported) => void,
+  +'ExportSpecifier[local]'?: (node: ExportSpecifier_With_local) => void,
+  +ExpressionStatement?: (node: ExpressionStatement) => void,
+  +'ExpressionStatement[expression]'?: (
+    node: ExpressionStatement_With_expression,
+  ) => void,
+  +'ExpressionStatement[directive]'?: (
+    node: ExpressionStatement_With_directive,
+  ) => void,
+  +ForInStatement?: (node: ForInStatement) => void,
+  +'ForInStatement[left]'?: (node: ForInStatement_With_left) => void,
+  +'ForInStatement[right]'?: (node: ForInStatement_With_right) => void,
+  +'ForInStatement[body]'?: (node: ForInStatement_With_body) => void,
+  +ForOfStatement?: (node: ForOfStatement) => void,
+  +'ForOfStatement[left]'?: (node: ForOfStatement_With_left) => void,
+  +'ForOfStatement[right]'?: (node: ForOfStatement_With_right) => void,
+  +'ForOfStatement[body]'?: (node: ForOfStatement_With_body) => void,
+  +'ForOfStatement[await]'?: (node: ForOfStatement_With_await) => void,
+  +ForStatement?: (node: ForStatement) => void,
+  +'ForStatement[init]'?: (node: ForStatement_With_init) => void,
+  +'ForStatement[test]'?: (node: ForStatement_With_test) => void,
+  +'ForStatement[update]'?: (node: ForStatement_With_update) => void,
+  +'ForStatement[body]'?: (node: ForStatement_With_body) => void,
+  +FunctionDeclaration?: (node: FunctionDeclaration) => void,
+  +'FunctionDeclaration[id]'?: (node: FunctionDeclaration_With_id) => void,
+  +'FunctionDeclaration[params]'?: (
+    node: FunctionDeclaration_With_params,
+  ) => void,
+  +'FunctionDeclaration[body]'?: (node: FunctionDeclaration_With_body) => void,
+  +'FunctionDeclaration[typeParameters]'?: (
+    node: FunctionDeclaration_With_typeParameters,
+  ) => void,
+  +'FunctionDeclaration[returnType]'?: (
+    node: FunctionDeclaration_With_returnType,
+  ) => void,
+  +'FunctionDeclaration[predicate]'?: (
+    node: FunctionDeclaration_With_predicate,
+  ) => void,
+  +'FunctionDeclaration[generator]'?: (
+    node: FunctionDeclaration_With_generator,
+  ) => void,
+  +'FunctionDeclaration[async]'?: (
+    node: FunctionDeclaration_With_async,
+  ) => void,
+  +FunctionExpression?: (node: FunctionExpression) => void,
+  +'FunctionExpression[id]'?: (node: FunctionExpression_With_id) => void,
+  +'FunctionExpression[params]'?: (
+    node: FunctionExpression_With_params,
+  ) => void,
+  +'FunctionExpression[body]'?: (node: FunctionExpression_With_body) => void,
+  +'FunctionExpression[typeParameters]'?: (
+    node: FunctionExpression_With_typeParameters,
+  ) => void,
+  +'FunctionExpression[returnType]'?: (
+    node: FunctionExpression_With_returnType,
+  ) => void,
+  +'FunctionExpression[predicate]'?: (
+    node: FunctionExpression_With_predicate,
+  ) => void,
+  +'FunctionExpression[generator]'?: (
+    node: FunctionExpression_With_generator,
+  ) => void,
+  +'FunctionExpression[async]'?: (node: FunctionExpression_With_async) => void,
+  +FunctionTypeAnnotation?: (node: FunctionTypeAnnotation) => void,
+  +'FunctionTypeAnnotation[params]'?: (
+    node: FunctionTypeAnnotation_With_params,
+  ) => void,
+  +'FunctionTypeAnnotation[this]'?: (
+    node: FunctionTypeAnnotation_With_this,
+  ) => void,
+  +'FunctionTypeAnnotation[returnType]'?: (
+    node: FunctionTypeAnnotation_With_returnType,
+  ) => void,
+  +'FunctionTypeAnnotation[rest]'?: (
+    node: FunctionTypeAnnotation_With_rest,
+  ) => void,
+  +'FunctionTypeAnnotation[typeParameters]'?: (
+    node: FunctionTypeAnnotation_With_typeParameters,
+  ) => void,
+  +FunctionTypeParam?: (node: FunctionTypeParam) => void,
+  +'FunctionTypeParam[name]'?: (node: FunctionTypeParam_With_name) => void,
+  +'FunctionTypeParam[typeAnnotation]'?: (
+    node: FunctionTypeParam_With_typeAnnotation,
+  ) => void,
+  +'FunctionTypeParam[optional]'?: (
+    node: FunctionTypeParam_With_optional,
+  ) => void,
+  +GenericTypeAnnotation?: (node: GenericTypeAnnotation) => void,
+  +'GenericTypeAnnotation[id]'?: (node: GenericTypeAnnotation_With_id) => void,
+  +'GenericTypeAnnotation[typeParameters]'?: (
+    node: GenericTypeAnnotation_With_typeParameters,
+  ) => void,
+  +Identifier?: (node: Identifier) => void,
+  +'Identifier[name]'?: (node: Identifier_With_name) => void,
+  +'Identifier[typeAnnotation]'?: (
+    node: Identifier_With_typeAnnotation,
+  ) => void,
+  +'Identifier[optional]'?: (node: Identifier_With_optional) => void,
+  +IfStatement?: (node: IfStatement) => void,
+  +'IfStatement[test]'?: (node: IfStatement_With_test) => void,
+  +'IfStatement[consequent]'?: (node: IfStatement_With_consequent) => void,
+  +'IfStatement[alternate]'?: (node: IfStatement_With_alternate) => void,
+  +ImportAttribute?: (node: ImportAttribute) => void,
+  +'ImportAttribute[key]'?: (node: ImportAttribute_With_key) => void,
+  +'ImportAttribute[value]'?: (node: ImportAttribute_With_value) => void,
+  +ImportDeclaration?: (node: ImportDeclaration) => void,
+  +'ImportDeclaration[specifiers]'?: (
+    node: ImportDeclaration_With_specifiers,
+  ) => void,
+  +'ImportDeclaration[source]'?: (node: ImportDeclaration_With_source) => void,
+  +'ImportDeclaration[assertions]'?: (
+    node: ImportDeclaration_With_assertions,
+  ) => void,
+  +'ImportDeclaration[importKind]'?: (
+    node: ImportDeclaration_With_importKind,
+  ) => void,
+  +ImportDefaultSpecifier?: (node: ImportDefaultSpecifier) => void,
+  +'ImportDefaultSpecifier[local]'?: (
+    node: ImportDefaultSpecifier_With_local,
+  ) => void,
+  +ImportExpression?: (node: ImportExpression) => void,
+  +'ImportExpression[source]'?: (node: ImportExpression_With_source) => void,
+  +'ImportExpression[attributes]'?: (
+    node: ImportExpression_With_attributes,
+  ) => void,
+  +ImportNamespaceSpecifier?: (node: ImportNamespaceSpecifier) => void,
+  +'ImportNamespaceSpecifier[local]'?: (
+    node: ImportNamespaceSpecifier_With_local,
+  ) => void,
+  +ImportSpecifier?: (node: ImportSpecifier) => void,
+  +'ImportSpecifier[imported]'?: (node: ImportSpecifier_With_imported) => void,
+  +'ImportSpecifier[local]'?: (node: ImportSpecifier_With_local) => void,
+  +'ImportSpecifier[importKind]'?: (
+    node: ImportSpecifier_With_importKind,
+  ) => void,
+  +IndexedAccessType?: (node: IndexedAccessType) => void,
+  +'IndexedAccessType[objectType]'?: (
+    node: IndexedAccessType_With_objectType,
+  ) => void,
+  +'IndexedAccessType[indexType]'?: (
+    node: IndexedAccessType_With_indexType,
+  ) => void,
+  +InferredPredicate?: (node: InferredPredicate) => void,
+  +InterfaceDeclaration?: (node: InterfaceDeclaration) => void,
+  +'InterfaceDeclaration[id]'?: (node: InterfaceDeclaration_With_id) => void,
+  +'InterfaceDeclaration[typeParameters]'?: (
+    node: InterfaceDeclaration_With_typeParameters,
+  ) => void,
+  +'InterfaceDeclaration[extends]'?: (
+    node: InterfaceDeclaration_With_extends,
+  ) => void,
+  +'InterfaceDeclaration[body]'?: (
+    node: InterfaceDeclaration_With_body,
+  ) => void,
+  +InterfaceExtends?: (node: InterfaceExtends) => void,
+  +'InterfaceExtends[id]'?: (node: InterfaceExtends_With_id) => void,
+  +'InterfaceExtends[typeParameters]'?: (
+    node: InterfaceExtends_With_typeParameters,
+  ) => void,
+  +InterfaceTypeAnnotation?: (node: InterfaceTypeAnnotation) => void,
+  +'InterfaceTypeAnnotation[extends]'?: (
+    node: InterfaceTypeAnnotation_With_extends,
+  ) => void,
+  +'InterfaceTypeAnnotation[body]'?: (
+    node: InterfaceTypeAnnotation_With_body,
+  ) => void,
+  +IntersectionTypeAnnotation?: (node: IntersectionTypeAnnotation) => void,
+  +'IntersectionTypeAnnotation[types]'?: (
+    node: IntersectionTypeAnnotation_With_types,
+  ) => void,
+  +JSXAttribute?: (node: JSXAttribute) => void,
+  +'JSXAttribute[name]'?: (node: JSXAttribute_With_name) => void,
+  +'JSXAttribute[value]'?: (node: JSXAttribute_With_value) => void,
+  +JSXClosingElement?: (node: JSXClosingElement) => void,
+  +'JSXClosingElement[name]'?: (node: JSXClosingElement_With_name) => void,
+  +JSXClosingFragment?: (node: JSXClosingFragment) => void,
+  +JSXElement?: (node: JSXElement) => void,
+  +'JSXElement[openingElement]'?: (
+    node: JSXElement_With_openingElement,
+  ) => void,
+  +'JSXElement[children]'?: (node: JSXElement_With_children) => void,
+  +'JSXElement[closingElement]'?: (
+    node: JSXElement_With_closingElement,
+  ) => void,
+  +JSXEmptyExpression?: (node: JSXEmptyExpression) => void,
+  +JSXExpressionContainer?: (node: JSXExpressionContainer) => void,
+  +'JSXExpressionContainer[expression]'?: (
+    node: JSXExpressionContainer_With_expression,
+  ) => void,
+  +JSXFragment?: (node: JSXFragment) => void,
+  +'JSXFragment[openingFragment]'?: (
+    node: JSXFragment_With_openingFragment,
+  ) => void,
+  +'JSXFragment[children]'?: (node: JSXFragment_With_children) => void,
+  +'JSXFragment[closingFragment]'?: (
+    node: JSXFragment_With_closingFragment,
+  ) => void,
+  +JSXIdentifier?: (node: JSXIdentifier) => void,
+  +'JSXIdentifier[name]'?: (node: JSXIdentifier_With_name) => void,
+  +JSXMemberExpression?: (node: JSXMemberExpression) => void,
+  +'JSXMemberExpression[object]'?: (
+    node: JSXMemberExpression_With_object,
+  ) => void,
+  +'JSXMemberExpression[property]'?: (
+    node: JSXMemberExpression_With_property,
+  ) => void,
+  +JSXNamespacedName?: (node: JSXNamespacedName) => void,
+  +'JSXNamespacedName[namespace]'?: (
+    node: JSXNamespacedName_With_namespace,
+  ) => void,
+  +'JSXNamespacedName[name]'?: (node: JSXNamespacedName_With_name) => void,
+  +JSXOpeningElement?: (node: JSXOpeningElement) => void,
+  +'JSXOpeningElement[name]'?: (node: JSXOpeningElement_With_name) => void,
+  +'JSXOpeningElement[attributes]'?: (
+    node: JSXOpeningElement_With_attributes,
+  ) => void,
+  +'JSXOpeningElement[selfClosing]'?: (
+    node: JSXOpeningElement_With_selfClosing,
+  ) => void,
+  +JSXOpeningFragment?: (node: JSXOpeningFragment) => void,
+  +JSXSpreadAttribute?: (node: JSXSpreadAttribute) => void,
+  +'JSXSpreadAttribute[argument]'?: (
+    node: JSXSpreadAttribute_With_argument,
+  ) => void,
+  +JSXSpreadChild?: (node: JSXSpreadChild) => void,
+  +'JSXSpreadChild[expression]'?: (
+    node: JSXSpreadChild_With_expression,
+  ) => void,
+  +JSXText?: (node: JSXText) => void,
+  +'JSXText[value]'?: (node: JSXText_With_value) => void,
+  +'JSXText[raw]'?: (node: JSXText_With_raw) => void,
+  +LabeledStatement?: (node: LabeledStatement) => void,
+  +'LabeledStatement[label]'?: (node: LabeledStatement_With_label) => void,
+  +'LabeledStatement[body]'?: (node: LabeledStatement_With_body) => void,
+  +LogicalExpression?: (node: LogicalExpression) => void,
+  +'LogicalExpression[left]'?: (node: LogicalExpression_With_left) => void,
+  +'LogicalExpression[right]'?: (node: LogicalExpression_With_right) => void,
+  +'LogicalExpression[operator]'?: (
+    node: LogicalExpression_With_operator,
+  ) => void,
+  +MemberExpression?: (node: MemberExpression) => void,
+  +'MemberExpression[object]'?: (node: MemberExpression_With_object) => void,
+  +'MemberExpression[property]'?: (
+    node: MemberExpression_With_property,
+  ) => void,
+  +'MemberExpression[computed]'?: (
+    node: MemberExpression_With_computed,
+  ) => void,
+  +MetaProperty?: (node: MetaProperty) => void,
+  +'MetaProperty[meta]'?: (node: MetaProperty_With_meta) => void,
+  +'MetaProperty[property]'?: (node: MetaProperty_With_property) => void,
+  +MethodDefinition?: (node: MethodDefinition) => void,
+  +'MethodDefinition[key]'?: (node: MethodDefinition_With_key) => void,
+  +'MethodDefinition[value]'?: (node: MethodDefinition_With_value) => void,
+  +'MethodDefinition[kind]'?: (node: MethodDefinition_With_kind) => void,
+  +'MethodDefinition[computed]'?: (
+    node: MethodDefinition_With_computed,
+  ) => void,
+  +'MethodDefinition[static]'?: (node: MethodDefinition_With_static) => void,
+  +MixedTypeAnnotation?: (node: MixedTypeAnnotation) => void,
+  +NewExpression?: (node: NewExpression) => void,
+  +'NewExpression[callee]'?: (node: NewExpression_With_callee) => void,
+  +'NewExpression[typeArguments]'?: (
+    node: NewExpression_With_typeArguments,
+  ) => void,
+  +'NewExpression[arguments]'?: (node: NewExpression_With_arguments) => void,
+  +NullableTypeAnnotation?: (node: NullableTypeAnnotation) => void,
+  +'NullableTypeAnnotation[typeAnnotation]'?: (
+    node: NullableTypeAnnotation_With_typeAnnotation,
+  ) => void,
+  +NullLiteralTypeAnnotation?: (node: NullLiteralTypeAnnotation) => void,
+  +NumberLiteralTypeAnnotation?: (node: NumberLiteralTypeAnnotation) => void,
+  +'NumberLiteralTypeAnnotation[value]'?: (
+    node: NumberLiteralTypeAnnotation_With_value,
+  ) => void,
+  +'NumberLiteralTypeAnnotation[raw]'?: (
+    node: NumberLiteralTypeAnnotation_With_raw,
+  ) => void,
+  +NumberTypeAnnotation?: (node: NumberTypeAnnotation) => void,
+  +ObjectExpression?: (node: ObjectExpression) => void,
+  +'ObjectExpression[properties]'?: (
+    node: ObjectExpression_With_properties,
+  ) => void,
+  +ObjectPattern?: (node: ObjectPattern) => void,
+  +'ObjectPattern[properties]'?: (node: ObjectPattern_With_properties) => void,
+  +'ObjectPattern[typeAnnotation]'?: (
+    node: ObjectPattern_With_typeAnnotation,
+  ) => void,
+  +ObjectTypeAnnotation?: (node: ObjectTypeAnnotation) => void,
+  +'ObjectTypeAnnotation[properties]'?: (
+    node: ObjectTypeAnnotation_With_properties,
+  ) => void,
+  +'ObjectTypeAnnotation[indexers]'?: (
+    node: ObjectTypeAnnotation_With_indexers,
+  ) => void,
+  +'ObjectTypeAnnotation[callProperties]'?: (
+    node: ObjectTypeAnnotation_With_callProperties,
+  ) => void,
+  +'ObjectTypeAnnotation[internalSlots]'?: (
+    node: ObjectTypeAnnotation_With_internalSlots,
+  ) => void,
+  +'ObjectTypeAnnotation[inexact]'?: (
+    node: ObjectTypeAnnotation_With_inexact,
+  ) => void,
+  +'ObjectTypeAnnotation[exact]'?: (
+    node: ObjectTypeAnnotation_With_exact,
+  ) => void,
+  +ObjectTypeCallProperty?: (node: ObjectTypeCallProperty) => void,
+  +'ObjectTypeCallProperty[value]'?: (
+    node: ObjectTypeCallProperty_With_value,
+  ) => void,
+  +'ObjectTypeCallProperty[static]'?: (
+    node: ObjectTypeCallProperty_With_static,
+  ) => void,
+  +ObjectTypeIndexer?: (node: ObjectTypeIndexer) => void,
+  +'ObjectTypeIndexer[id]'?: (node: ObjectTypeIndexer_With_id) => void,
+  +'ObjectTypeIndexer[key]'?: (node: ObjectTypeIndexer_With_key) => void,
+  +'ObjectTypeIndexer[value]'?: (node: ObjectTypeIndexer_With_value) => void,
+  +'ObjectTypeIndexer[static]'?: (node: ObjectTypeIndexer_With_static) => void,
+  +'ObjectTypeIndexer[variance]'?: (
+    node: ObjectTypeIndexer_With_variance,
+  ) => void,
+  +ObjectTypeInternalSlot?: (node: ObjectTypeInternalSlot) => void,
+  +'ObjectTypeInternalSlot[id]'?: (
+    node: ObjectTypeInternalSlot_With_id,
+  ) => void,
+  +'ObjectTypeInternalSlot[value]'?: (
+    node: ObjectTypeInternalSlot_With_value,
+  ) => void,
+  +'ObjectTypeInternalSlot[optional]'?: (
+    node: ObjectTypeInternalSlot_With_optional,
+  ) => void,
+  +'ObjectTypeInternalSlot[static]'?: (
+    node: ObjectTypeInternalSlot_With_static,
+  ) => void,
+  +'ObjectTypeInternalSlot[method]'?: (
+    node: ObjectTypeInternalSlot_With_method,
+  ) => void,
+  +ObjectTypeProperty?: (node: ObjectTypeProperty) => void,
+  +'ObjectTypeProperty[key]'?: (node: ObjectTypeProperty_With_key) => void,
+  +'ObjectTypeProperty[value]'?: (node: ObjectTypeProperty_With_value) => void,
+  +'ObjectTypeProperty[method]'?: (
+    node: ObjectTypeProperty_With_method,
+  ) => void,
+  +'ObjectTypeProperty[optional]'?: (
+    node: ObjectTypeProperty_With_optional,
+  ) => void,
+  +'ObjectTypeProperty[static]'?: (
+    node: ObjectTypeProperty_With_static,
+  ) => void,
+  +'ObjectTypeProperty[proto]'?: (node: ObjectTypeProperty_With_proto) => void,
+  +'ObjectTypeProperty[variance]'?: (
+    node: ObjectTypeProperty_With_variance,
+  ) => void,
+  +'ObjectTypeProperty[kind]'?: (node: ObjectTypeProperty_With_kind) => void,
+  +ObjectTypeSpreadProperty?: (node: ObjectTypeSpreadProperty) => void,
+  +'ObjectTypeSpreadProperty[argument]'?: (
+    node: ObjectTypeSpreadProperty_With_argument,
+  ) => void,
+  +OpaqueType?: (node: OpaqueType) => void,
+  +'OpaqueType[id]'?: (node: OpaqueType_With_id) => void,
+  +'OpaqueType[typeParameters]'?: (
+    node: OpaqueType_With_typeParameters,
+  ) => void,
+  +'OpaqueType[impltype]'?: (node: OpaqueType_With_impltype) => void,
+  +'OpaqueType[supertype]'?: (node: OpaqueType_With_supertype) => void,
+  +OptionalCallExpression?: (node: OptionalCallExpression) => void,
+  +'OptionalCallExpression[callee]'?: (
+    node: OptionalCallExpression_With_callee,
+  ) => void,
+  +'OptionalCallExpression[typeArguments]'?: (
+    node: OptionalCallExpression_With_typeArguments,
+  ) => void,
+  +'OptionalCallExpression[arguments]'?: (
+    node: OptionalCallExpression_With_arguments,
+  ) => void,
+  +'OptionalCallExpression[optional]'?: (
+    node: OptionalCallExpression_With_optional,
+  ) => void,
+  +OptionalIndexedAccessType?: (node: OptionalIndexedAccessType) => void,
+  +'OptionalIndexedAccessType[objectType]'?: (
+    node: OptionalIndexedAccessType_With_objectType,
+  ) => void,
+  +'OptionalIndexedAccessType[indexType]'?: (
+    node: OptionalIndexedAccessType_With_indexType,
+  ) => void,
+  +'OptionalIndexedAccessType[optional]'?: (
+    node: OptionalIndexedAccessType_With_optional,
+  ) => void,
+  +OptionalMemberExpression?: (node: OptionalMemberExpression) => void,
+  +'OptionalMemberExpression[object]'?: (
+    node: OptionalMemberExpression_With_object,
+  ) => void,
+  +'OptionalMemberExpression[property]'?: (
+    node: OptionalMemberExpression_With_property,
+  ) => void,
+  +'OptionalMemberExpression[computed]'?: (
+    node: OptionalMemberExpression_With_computed,
+  ) => void,
+  +'OptionalMemberExpression[optional]'?: (
+    node: OptionalMemberExpression_With_optional,
+  ) => void,
+  +PrivateName?: (node: PrivateName) => void,
+  +'PrivateName[id]'?: (node: PrivateName_With_id) => void,
+  +Program?: (node: Program) => void,
+  +'Program[body]'?: (node: Program_With_body) => void,
+  +Property?: (node: Property) => void,
+  +'Property[key]'?: (node: Property_With_key) => void,
+  +'Property[value]'?: (node: Property_With_value) => void,
+  +'Property[kind]'?: (node: Property_With_kind) => void,
+  +'Property[computed]'?: (node: Property_With_computed) => void,
+  +'Property[method]'?: (node: Property_With_method) => void,
+  +'Property[shorthand]'?: (node: Property_With_shorthand) => void,
+  +QualifiedTypeIdentifier?: (node: QualifiedTypeIdentifier) => void,
+  +'QualifiedTypeIdentifier[qualification]'?: (
+    node: QualifiedTypeIdentifier_With_qualification,
+  ) => void,
+  +'QualifiedTypeIdentifier[id]'?: (
+    node: QualifiedTypeIdentifier_With_id,
+  ) => void,
+  +RestElement?: (node: RestElement) => void,
+  +'RestElement[argument]'?: (node: RestElement_With_argument) => void,
+  +ReturnStatement?: (node: ReturnStatement) => void,
+  +'ReturnStatement[argument]'?: (node: ReturnStatement_With_argument) => void,
+  +SequenceExpression?: (node: SequenceExpression) => void,
+  +'SequenceExpression[expressions]'?: (
+    node: SequenceExpression_With_expressions,
+  ) => void,
+  +SpreadElement?: (node: SpreadElement) => void,
+  +'SpreadElement[argument]'?: (node: SpreadElement_With_argument) => void,
+  +StringLiteralTypeAnnotation?: (node: StringLiteralTypeAnnotation) => void,
+  +'StringLiteralTypeAnnotation[value]'?: (
+    node: StringLiteralTypeAnnotation_With_value,
+  ) => void,
+  +StringTypeAnnotation?: (node: StringTypeAnnotation) => void,
+  +Super?: (node: Super) => void,
+  +SwitchCase?: (node: SwitchCase) => void,
+  +'SwitchCase[test]'?: (node: SwitchCase_With_test) => void,
+  +'SwitchCase[consequent]'?: (node: SwitchCase_With_consequent) => void,
+  +SwitchStatement?: (node: SwitchStatement) => void,
+  +'SwitchStatement[discriminant]'?: (
+    node: SwitchStatement_With_discriminant,
+  ) => void,
+  +'SwitchStatement[cases]'?: (node: SwitchStatement_With_cases) => void,
+  +SymbolTypeAnnotation?: (node: SymbolTypeAnnotation) => void,
+  +TaggedTemplateExpression?: (node: TaggedTemplateExpression) => void,
+  +'TaggedTemplateExpression[tag]'?: (
+    node: TaggedTemplateExpression_With_tag,
+  ) => void,
+  +'TaggedTemplateExpression[quasi]'?: (
+    node: TaggedTemplateExpression_With_quasi,
+  ) => void,
+  +TemplateElement?: (node: TemplateElement) => void,
+  +'TemplateElement[tail]'?: (node: TemplateElement_With_tail) => void,
+  +'TemplateElement[cooked]'?: (node: TemplateElement_With_cooked) => void,
+  +'TemplateElement[raw]'?: (node: TemplateElement_With_raw) => void,
+  +TemplateLiteral?: (node: TemplateLiteral) => void,
+  +'TemplateLiteral[quasis]'?: (node: TemplateLiteral_With_quasis) => void,
+  +'TemplateLiteral[expressions]'?: (
+    node: TemplateLiteral_With_expressions,
+  ) => void,
+  +ThisExpression?: (node: ThisExpression) => void,
+  +ThisTypeAnnotation?: (node: ThisTypeAnnotation) => void,
+  +ThrowStatement?: (node: ThrowStatement) => void,
+  +'ThrowStatement[argument]'?: (node: ThrowStatement_With_argument) => void,
+  +TryStatement?: (node: TryStatement) => void,
+  +'TryStatement[block]'?: (node: TryStatement_With_block) => void,
+  +'TryStatement[handler]'?: (node: TryStatement_With_handler) => void,
+  +'TryStatement[finalizer]'?: (node: TryStatement_With_finalizer) => void,
+  +TupleTypeAnnotation?: (node: TupleTypeAnnotation) => void,
+  +'TupleTypeAnnotation[types]'?: (
+    node: TupleTypeAnnotation_With_types,
+  ) => void,
+  +TypeAlias?: (node: TypeAlias) => void,
+  +'TypeAlias[id]'?: (node: TypeAlias_With_id) => void,
+  +'TypeAlias[typeParameters]'?: (node: TypeAlias_With_typeParameters) => void,
+  +'TypeAlias[right]'?: (node: TypeAlias_With_right) => void,
+  +TypeAnnotation?: (node: TypeAnnotation) => void,
+  +'TypeAnnotation[typeAnnotation]'?: (
+    node: TypeAnnotation_With_typeAnnotation,
+  ) => void,
+  +TypeCastExpression?: (node: TypeCastExpression) => void,
+  +'TypeCastExpression[expression]'?: (
+    node: TypeCastExpression_With_expression,
+  ) => void,
+  +'TypeCastExpression[typeAnnotation]'?: (
+    node: TypeCastExpression_With_typeAnnotation,
+  ) => void,
+  +TypeofTypeAnnotation?: (node: TypeofTypeAnnotation) => void,
+  +'TypeofTypeAnnotation[argument]'?: (
+    node: TypeofTypeAnnotation_With_argument,
+  ) => void,
+  +TypeParameter?: (node: TypeParameter) => void,
+  +'TypeParameter[name]'?: (node: TypeParameter_With_name) => void,
+  +'TypeParameter[bound]'?: (node: TypeParameter_With_bound) => void,
+  +'TypeParameter[variance]'?: (node: TypeParameter_With_variance) => void,
+  +'TypeParameter[default]'?: (node: TypeParameter_With_default) => void,
+  +TypeParameterDeclaration?: (node: TypeParameterDeclaration) => void,
+  +'TypeParameterDeclaration[params]'?: (
+    node: TypeParameterDeclaration_With_params,
+  ) => void,
+  +TypeParameterInstantiation?: (node: TypeParameterInstantiation) => void,
+  +'TypeParameterInstantiation[params]'?: (
+    node: TypeParameterInstantiation_With_params,
+  ) => void,
+  +UnaryExpression?: (node: UnaryExpression) => void,
+  +'UnaryExpression[operator]'?: (node: UnaryExpression_With_operator) => void,
+  +'UnaryExpression[argument]'?: (node: UnaryExpression_With_argument) => void,
+  +'UnaryExpression[prefix]'?: (node: UnaryExpression_With_prefix) => void,
+  +UnionTypeAnnotation?: (node: UnionTypeAnnotation) => void,
+  +'UnionTypeAnnotation[types]'?: (
+    node: UnionTypeAnnotation_With_types,
+  ) => void,
+  +UpdateExpression?: (node: UpdateExpression) => void,
+  +'UpdateExpression[operator]'?: (
+    node: UpdateExpression_With_operator,
+  ) => void,
+  +'UpdateExpression[argument]'?: (
+    node: UpdateExpression_With_argument,
+  ) => void,
+  +'UpdateExpression[prefix]'?: (node: UpdateExpression_With_prefix) => void,
+  +VariableDeclaration?: (node: VariableDeclaration) => void,
+  +'VariableDeclaration[kind]'?: (node: VariableDeclaration_With_kind) => void,
+  +'VariableDeclaration[declarations]'?: (
+    node: VariableDeclaration_With_declarations,
+  ) => void,
+  +VariableDeclarator?: (node: VariableDeclarator) => void,
+  +'VariableDeclarator[init]'?: (node: VariableDeclarator_With_init) => void,
+  +'VariableDeclarator[id]'?: (node: VariableDeclarator_With_id) => void,
+  +Variance?: (node: Variance) => void,
+  +'Variance[kind]'?: (node: Variance_With_kind) => void,
+  +VoidTypeAnnotation?: (node: VoidTypeAnnotation) => void,
+  +WhileStatement?: (node: WhileStatement) => void,
+  +'WhileStatement[body]'?: (node: WhileStatement_With_body) => void,
+  +'WhileStatement[test]'?: (node: WhileStatement_With_test) => void,
+  +WithStatement?: (node: WithStatement) => void,
+  +'WithStatement[object]'?: (node: WithStatement_With_object) => void,
+  +'WithStatement[body]'?: (node: WithStatement_With_body) => void,
+  +YieldExpression?: (node: YieldExpression) => void,
+  +'YieldExpression[argument]'?: (node: YieldExpression_With_argument) => void,
+  +'YieldExpression[delegate]'?: (node: YieldExpression_With_delegate) => void,
+  +Literal?: (node: Literal) => void,
+  +'*'?: (node: StarSpecialSelector) => void,
+  +':statement'?: (node: StatementSpecialSelector) => void,
+  +':declaration'?: (node: DeclarationSpecialSelector) => void,
+  +':pattern'?: (node: PatternSpecialSelector) => void,
+  +':expression'?: (node: ExpressionSpecialSelector) => void,
+  +':function'?: (node: FunctionSpecialSelector) => void,
+  +'AnyTypeAnnotation:exit'?: (node: AnyTypeAnnotation) => void,
+  +'ArrayExpression:exit'?: (node: ArrayExpression) => void,
+  +'ArrayExpression[elements]:exit'?: (
+    node: ArrayExpression_With_elements,
+  ) => void,
+  +'ArrayExpression[trailingComma]:exit'?: (
+    node: ArrayExpression_With_trailingComma,
+  ) => void,
+  +'ArrayPattern:exit'?: (node: ArrayPattern) => void,
+  +'ArrayPattern[elements]:exit'?: (node: ArrayPattern_With_elements) => void,
+  +'ArrayPattern[typeAnnotation]:exit'?: (
+    node: ArrayPattern_With_typeAnnotation,
+  ) => void,
+  +'ArrayTypeAnnotation:exit'?: (node: ArrayTypeAnnotation) => void,
+  +'ArrayTypeAnnotation[elementType]:exit'?: (
+    node: ArrayTypeAnnotation_With_elementType,
+  ) => void,
+  +'ArrowFunctionExpression:exit'?: (node: ArrowFunctionExpression) => void,
+  +'ArrowFunctionExpression[id]:exit'?: (
+    node: ArrowFunctionExpression_With_id,
+  ) => void,
+  +'ArrowFunctionExpression[params]:exit'?: (
+    node: ArrowFunctionExpression_With_params,
+  ) => void,
+  +'ArrowFunctionExpression[body]:exit'?: (
+    node: ArrowFunctionExpression_With_body,
+  ) => void,
+  +'ArrowFunctionExpression[typeParameters]:exit'?: (
+    node: ArrowFunctionExpression_With_typeParameters,
+  ) => void,
+  +'ArrowFunctionExpression[returnType]:exit'?: (
+    node: ArrowFunctionExpression_With_returnType,
+  ) => void,
+  +'ArrowFunctionExpression[predicate]:exit'?: (
+    node: ArrowFunctionExpression_With_predicate,
+  ) => void,
+  +'ArrowFunctionExpression[expression]:exit'?: (
+    node: ArrowFunctionExpression_With_expression,
+  ) => void,
+  +'ArrowFunctionExpression[async]:exit'?: (
+    node: ArrowFunctionExpression_With_async,
+  ) => void,
+  +'AssignmentExpression:exit'?: (node: AssignmentExpression) => void,
+  +'AssignmentExpression[operator]:exit'?: (
+    node: AssignmentExpression_With_operator,
+  ) => void,
+  +'AssignmentExpression[left]:exit'?: (
+    node: AssignmentExpression_With_left,
+  ) => void,
+  +'AssignmentExpression[right]:exit'?: (
+    node: AssignmentExpression_With_right,
+  ) => void,
+  +'AssignmentPattern:exit'?: (node: AssignmentPattern) => void,
+  +'AssignmentPattern[left]:exit'?: (node: AssignmentPattern_With_left) => void,
+  +'AssignmentPattern[right]:exit'?: (
+    node: AssignmentPattern_With_right,
+  ) => void,
+  +'AwaitExpression:exit'?: (node: AwaitExpression) => void,
+  +'AwaitExpression[argument]:exit'?: (
+    node: AwaitExpression_With_argument,
+  ) => void,
+  +'BinaryExpression:exit'?: (node: BinaryExpression) => void,
+  +'BinaryExpression[left]:exit'?: (node: BinaryExpression_With_left) => void,
+  +'BinaryExpression[right]:exit'?: (node: BinaryExpression_With_right) => void,
+  +'BinaryExpression[operator]:exit'?: (
+    node: BinaryExpression_With_operator,
+  ) => void,
+  +'BlockStatement:exit'?: (node: BlockStatement) => void,
+  +'BlockStatement[body]:exit'?: (node: BlockStatement_With_body) => void,
+  +'BooleanLiteralTypeAnnotation:exit'?: (
+    node: BooleanLiteralTypeAnnotation,
+  ) => void,
+  +'BooleanLiteralTypeAnnotation[value]:exit'?: (
+    node: BooleanLiteralTypeAnnotation_With_value,
+  ) => void,
+  +'BooleanLiteralTypeAnnotation[raw]:exit'?: (
+    node: BooleanLiteralTypeAnnotation_With_raw,
+  ) => void,
+  +'BooleanTypeAnnotation:exit'?: (node: BooleanTypeAnnotation) => void,
+  +'BreakStatement:exit'?: (node: BreakStatement) => void,
+  +'BreakStatement[label]:exit'?: (node: BreakStatement_With_label) => void,
+  +'CallExpression:exit'?: (node: CallExpression) => void,
+  +'CallExpression[callee]:exit'?: (node: CallExpression_With_callee) => void,
+  +'CallExpression[typeArguments]:exit'?: (
+    node: CallExpression_With_typeArguments,
+  ) => void,
+  +'CallExpression[arguments]:exit'?: (
+    node: CallExpression_With_arguments,
+  ) => void,
+  +'CatchClause:exit'?: (node: CatchClause) => void,
+  +'CatchClause[param]:exit'?: (node: CatchClause_With_param) => void,
+  +'CatchClause[body]:exit'?: (node: CatchClause_With_body) => void,
+  +'ClassBody:exit'?: (node: ClassBody) => void,
+  +'ClassBody[body]:exit'?: (node: ClassBody_With_body) => void,
+  +'ClassDeclaration:exit'?: (node: ClassDeclaration) => void,
+  +'ClassDeclaration[id]:exit'?: (node: ClassDeclaration_With_id) => void,
+  +'ClassDeclaration[typeParameters]:exit'?: (
+    node: ClassDeclaration_With_typeParameters,
+  ) => void,
+  +'ClassDeclaration[superClass]:exit'?: (
+    node: ClassDeclaration_With_superClass,
+  ) => void,
+  +'ClassDeclaration[superTypeParameters]:exit'?: (
+    node: ClassDeclaration_With_superTypeParameters,
+  ) => void,
+  +'ClassDeclaration[implements]:exit'?: (
+    node: ClassDeclaration_With_implements,
+  ) => void,
+  +'ClassDeclaration[decorators]:exit'?: (
+    node: ClassDeclaration_With_decorators,
+  ) => void,
+  +'ClassDeclaration[body]:exit'?: (node: ClassDeclaration_With_body) => void,
+  +'ClassExpression:exit'?: (node: ClassExpression) => void,
+  +'ClassExpression[id]:exit'?: (node: ClassExpression_With_id) => void,
+  +'ClassExpression[typeParameters]:exit'?: (
+    node: ClassExpression_With_typeParameters,
+  ) => void,
+  +'ClassExpression[superClass]:exit'?: (
+    node: ClassExpression_With_superClass,
+  ) => void,
+  +'ClassExpression[superTypeParameters]:exit'?: (
+    node: ClassExpression_With_superTypeParameters,
+  ) => void,
+  +'ClassExpression[implements]:exit'?: (
+    node: ClassExpression_With_implements,
+  ) => void,
+  +'ClassExpression[decorators]:exit'?: (
+    node: ClassExpression_With_decorators,
+  ) => void,
+  +'ClassExpression[body]:exit'?: (node: ClassExpression_With_body) => void,
+  +'ClassImplements:exit'?: (node: ClassImplements) => void,
+  +'ClassImplements[id]:exit'?: (node: ClassImplements_With_id) => void,
+  +'ClassImplements[typeParameters]:exit'?: (
+    node: ClassImplements_With_typeParameters,
+  ) => void,
+  +'ClassPrivateProperty:exit'?: (node: ClassPrivateProperty) => void,
+  +'ClassPrivateProperty[key]:exit'?: (
+    node: ClassPrivateProperty_With_key,
+  ) => void,
+  +'ClassPrivateProperty[value]:exit'?: (
+    node: ClassPrivateProperty_With_value,
+  ) => void,
+  +'ClassPrivateProperty[static]:exit'?: (
+    node: ClassPrivateProperty_With_static,
+  ) => void,
+  +'ClassPrivateProperty[declare]:exit'?: (
+    node: ClassPrivateProperty_With_declare,
+  ) => void,
+  +'ClassPrivateProperty[optional]:exit'?: (
+    node: ClassPrivateProperty_With_optional,
+  ) => void,
+  +'ClassPrivateProperty[variance]:exit'?: (
+    node: ClassPrivateProperty_With_variance,
+  ) => void,
+  +'ClassPrivateProperty[typeAnnotation]:exit'?: (
+    node: ClassPrivateProperty_With_typeAnnotation,
+  ) => void,
+  +'ClassProperty:exit'?: (node: ClassProperty) => void,
+  +'ClassProperty[key]:exit'?: (node: ClassProperty_With_key) => void,
+  +'ClassProperty[value]:exit'?: (node: ClassProperty_With_value) => void,
+  +'ClassProperty[computed]:exit'?: (node: ClassProperty_With_computed) => void,
+  +'ClassProperty[static]:exit'?: (node: ClassProperty_With_static) => void,
+  +'ClassProperty[declare]:exit'?: (node: ClassProperty_With_declare) => void,
+  +'ClassProperty[optional]:exit'?: (node: ClassProperty_With_optional) => void,
+  +'ClassProperty[variance]:exit'?: (node: ClassProperty_With_variance) => void,
+  +'ClassProperty[typeAnnotation]:exit'?: (
+    node: ClassProperty_With_typeAnnotation,
+  ) => void,
+  +'ConditionalExpression:exit'?: (node: ConditionalExpression) => void,
+  +'ConditionalExpression[test]:exit'?: (
+    node: ConditionalExpression_With_test,
+  ) => void,
+  +'ConditionalExpression[alternate]:exit'?: (
+    node: ConditionalExpression_With_alternate,
+  ) => void,
+  +'ConditionalExpression[consequent]:exit'?: (
+    node: ConditionalExpression_With_consequent,
+  ) => void,
+  +'ContinueStatement:exit'?: (node: ContinueStatement) => void,
+  +'ContinueStatement[label]:exit'?: (
+    node: ContinueStatement_With_label,
+  ) => void,
+  +'DebuggerStatement:exit'?: (node: DebuggerStatement) => void,
+  +'DeclareClass:exit'?: (node: DeclareClass) => void,
+  +'DeclareClass[id]:exit'?: (node: DeclareClass_With_id) => void,
+  +'DeclareClass[typeParameters]:exit'?: (
+    node: DeclareClass_With_typeParameters,
+  ) => void,
+  +'DeclareClass[extends]:exit'?: (node: DeclareClass_With_extends) => void,
+  +'DeclareClass[implements]:exit'?: (
+    node: DeclareClass_With_implements,
+  ) => void,
+  +'DeclareClass[mixins]:exit'?: (node: DeclareClass_With_mixins) => void,
+  +'DeclareClass[body]:exit'?: (node: DeclareClass_With_body) => void,
+  +'DeclaredPredicate:exit'?: (node: DeclaredPredicate) => void,
+  +'DeclaredPredicate[value]:exit'?: (
+    node: DeclaredPredicate_With_value,
+  ) => void,
+  +'DeclareExportAllDeclaration:exit'?: (
+    node: DeclareExportAllDeclaration,
+  ) => void,
+  +'DeclareExportAllDeclaration[source]:exit'?: (
+    node: DeclareExportAllDeclaration_With_source,
+  ) => void,
+  +'DeclareExportDeclaration:exit'?: (node: DeclareExportDeclaration) => void,
+  +'DeclareExportDeclaration[declaration]:exit'?: (
+    node: DeclareExportDeclaration_With_declaration,
+  ) => void,
+  +'DeclareExportDeclaration[specifiers]:exit'?: (
+    node: DeclareExportDeclaration_With_specifiers,
+  ) => void,
+  +'DeclareExportDeclaration[source]:exit'?: (
+    node: DeclareExportDeclaration_With_source,
+  ) => void,
+  +'DeclareExportDeclaration[default]:exit'?: (
+    node: DeclareExportDeclaration_With_default,
+  ) => void,
+  +'DeclareFunction:exit'?: (node: DeclareFunction) => void,
+  +'DeclareFunction[id]:exit'?: (node: DeclareFunction_With_id) => void,
+  +'DeclareFunction[predicate]:exit'?: (
+    node: DeclareFunction_With_predicate,
+  ) => void,
+  +'DeclareInterface:exit'?: (node: DeclareInterface) => void,
+  +'DeclareInterface[id]:exit'?: (node: DeclareInterface_With_id) => void,
+  +'DeclareInterface[typeParameters]:exit'?: (
+    node: DeclareInterface_With_typeParameters,
+  ) => void,
+  +'DeclareInterface[extends]:exit'?: (
+    node: DeclareInterface_With_extends,
+  ) => void,
+  +'DeclareInterface[body]:exit'?: (node: DeclareInterface_With_body) => void,
+  +'DeclareModule:exit'?: (node: DeclareModule) => void,
+  +'DeclareModule[id]:exit'?: (node: DeclareModule_With_id) => void,
+  +'DeclareModule[body]:exit'?: (node: DeclareModule_With_body) => void,
+  +'DeclareModule[kind]:exit'?: (node: DeclareModule_With_kind) => void,
+  +'DeclareModuleExports:exit'?: (node: DeclareModuleExports) => void,
+  +'DeclareModuleExports[typeAnnotation]:exit'?: (
+    node: DeclareModuleExports_With_typeAnnotation,
+  ) => void,
+  +'DeclareOpaqueType:exit'?: (node: DeclareOpaqueType) => void,
+  +'DeclareOpaqueType[id]:exit'?: (node: DeclareOpaqueType_With_id) => void,
+  +'DeclareOpaqueType[typeParameters]:exit'?: (
+    node: DeclareOpaqueType_With_typeParameters,
+  ) => void,
+  +'DeclareOpaqueType[impltype]:exit'?: (
+    node: DeclareOpaqueType_With_impltype,
+  ) => void,
+  +'DeclareOpaqueType[supertype]:exit'?: (
+    node: DeclareOpaqueType_With_supertype,
+  ) => void,
+  +'DeclareTypeAlias:exit'?: (node: DeclareTypeAlias) => void,
+  +'DeclareTypeAlias[id]:exit'?: (node: DeclareTypeAlias_With_id) => void,
+  +'DeclareTypeAlias[typeParameters]:exit'?: (
+    node: DeclareTypeAlias_With_typeParameters,
+  ) => void,
+  +'DeclareTypeAlias[right]:exit'?: (node: DeclareTypeAlias_With_right) => void,
+  +'DeclareVariable:exit'?: (node: DeclareVariable) => void,
+  +'DeclareVariable[id]:exit'?: (node: DeclareVariable_With_id) => void,
+  +'DoWhileStatement:exit'?: (node: DoWhileStatement) => void,
+  +'DoWhileStatement[body]:exit'?: (node: DoWhileStatement_With_body) => void,
+  +'DoWhileStatement[test]:exit'?: (node: DoWhileStatement_With_test) => void,
+  +'EmptyStatement:exit'?: (node: EmptyStatement) => void,
+  +'EmptyTypeAnnotation:exit'?: (node: EmptyTypeAnnotation) => void,
+  +'EnumBooleanBody:exit'?: (node: EnumBooleanBody) => void,
+  +'EnumBooleanBody[members]:exit'?: (
+    node: EnumBooleanBody_With_members,
+  ) => void,
+  +'EnumBooleanBody[explicitType]:exit'?: (
+    node: EnumBooleanBody_With_explicitType,
+  ) => void,
+  +'EnumBooleanBody[hasUnknownMembers]:exit'?: (
+    node: EnumBooleanBody_With_hasUnknownMembers,
+  ) => void,
+  +'EnumBooleanMember:exit'?: (node: EnumBooleanMember) => void,
+  +'EnumBooleanMember[id]:exit'?: (node: EnumBooleanMember_With_id) => void,
+  +'EnumBooleanMember[init]:exit'?: (node: EnumBooleanMember_With_init) => void,
+  +'EnumDeclaration:exit'?: (node: EnumDeclaration) => void,
+  +'EnumDeclaration[id]:exit'?: (node: EnumDeclaration_With_id) => void,
+  +'EnumDeclaration[body]:exit'?: (node: EnumDeclaration_With_body) => void,
+  +'EnumDefaultedMember:exit'?: (node: EnumDefaultedMember) => void,
+  +'EnumDefaultedMember[id]:exit'?: (node: EnumDefaultedMember_With_id) => void,
+  +'EnumNumberBody:exit'?: (node: EnumNumberBody) => void,
+  +'EnumNumberBody[members]:exit'?: (node: EnumNumberBody_With_members) => void,
+  +'EnumNumberBody[explicitType]:exit'?: (
+    node: EnumNumberBody_With_explicitType,
+  ) => void,
+  +'EnumNumberBody[hasUnknownMembers]:exit'?: (
+    node: EnumNumberBody_With_hasUnknownMembers,
+  ) => void,
+  +'EnumNumberMember:exit'?: (node: EnumNumberMember) => void,
+  +'EnumNumberMember[id]:exit'?: (node: EnumNumberMember_With_id) => void,
+  +'EnumNumberMember[init]:exit'?: (node: EnumNumberMember_With_init) => void,
+  +'EnumStringBody:exit'?: (node: EnumStringBody) => void,
+  +'EnumStringBody[members]:exit'?: (node: EnumStringBody_With_members) => void,
+  +'EnumStringBody[explicitType]:exit'?: (
+    node: EnumStringBody_With_explicitType,
+  ) => void,
+  +'EnumStringBody[hasUnknownMembers]:exit'?: (
+    node: EnumStringBody_With_hasUnknownMembers,
+  ) => void,
+  +'EnumStringMember:exit'?: (node: EnumStringMember) => void,
+  +'EnumStringMember[id]:exit'?: (node: EnumStringMember_With_id) => void,
+  +'EnumStringMember[init]:exit'?: (node: EnumStringMember_With_init) => void,
+  +'EnumSymbolBody:exit'?: (node: EnumSymbolBody) => void,
+  +'EnumSymbolBody[members]:exit'?: (node: EnumSymbolBody_With_members) => void,
+  +'EnumSymbolBody[hasUnknownMembers]:exit'?: (
+    node: EnumSymbolBody_With_hasUnknownMembers,
+  ) => void,
+  +'ExistsTypeAnnotation:exit'?: (node: ExistsTypeAnnotation) => void,
+  +'ExportAllDeclaration:exit'?: (node: ExportAllDeclaration) => void,
+  +'ExportAllDeclaration[source]:exit'?: (
+    node: ExportAllDeclaration_With_source,
+  ) => void,
+  +'ExportAllDeclaration[exportKind]:exit'?: (
+    node: ExportAllDeclaration_With_exportKind,
+  ) => void,
+  +'ExportDefaultDeclaration:exit'?: (node: ExportDefaultDeclaration) => void,
+  +'ExportDefaultDeclaration[declaration]:exit'?: (
+    node: ExportDefaultDeclaration_With_declaration,
+  ) => void,
+  +'ExportNamedDeclaration:exit'?: (node: ExportNamedDeclaration) => void,
+  +'ExportNamedDeclaration[declaration]:exit'?: (
+    node: ExportNamedDeclaration_With_declaration,
+  ) => void,
+  +'ExportNamedDeclaration[specifiers]:exit'?: (
+    node: ExportNamedDeclaration_With_specifiers,
+  ) => void,
+  +'ExportNamedDeclaration[source]:exit'?: (
+    node: ExportNamedDeclaration_With_source,
+  ) => void,
+  +'ExportNamedDeclaration[exportKind]:exit'?: (
+    node: ExportNamedDeclaration_With_exportKind,
+  ) => void,
+  +'ExportNamespaceSpecifier:exit'?: (node: ExportNamespaceSpecifier) => void,
+  +'ExportNamespaceSpecifier[exported]:exit'?: (
+    node: ExportNamespaceSpecifier_With_exported,
+  ) => void,
+  +'ExportSpecifier:exit'?: (node: ExportSpecifier) => void,
+  +'ExportSpecifier[exported]:exit'?: (
+    node: ExportSpecifier_With_exported,
+  ) => void,
+  +'ExportSpecifier[local]:exit'?: (node: ExportSpecifier_With_local) => void,
+  +'ExpressionStatement:exit'?: (node: ExpressionStatement) => void,
+  +'ExpressionStatement[expression]:exit'?: (
+    node: ExpressionStatement_With_expression,
+  ) => void,
+  +'ExpressionStatement[directive]:exit'?: (
+    node: ExpressionStatement_With_directive,
+  ) => void,
+  +'ForInStatement:exit'?: (node: ForInStatement) => void,
+  +'ForInStatement[left]:exit'?: (node: ForInStatement_With_left) => void,
+  +'ForInStatement[right]:exit'?: (node: ForInStatement_With_right) => void,
+  +'ForInStatement[body]:exit'?: (node: ForInStatement_With_body) => void,
+  +'ForOfStatement:exit'?: (node: ForOfStatement) => void,
+  +'ForOfStatement[left]:exit'?: (node: ForOfStatement_With_left) => void,
+  +'ForOfStatement[right]:exit'?: (node: ForOfStatement_With_right) => void,
+  +'ForOfStatement[body]:exit'?: (node: ForOfStatement_With_body) => void,
+  +'ForOfStatement[await]:exit'?: (node: ForOfStatement_With_await) => void,
+  +'ForStatement:exit'?: (node: ForStatement) => void,
+  +'ForStatement[init]:exit'?: (node: ForStatement_With_init) => void,
+  +'ForStatement[test]:exit'?: (node: ForStatement_With_test) => void,
+  +'ForStatement[update]:exit'?: (node: ForStatement_With_update) => void,
+  +'ForStatement[body]:exit'?: (node: ForStatement_With_body) => void,
+  +'FunctionDeclaration:exit'?: (node: FunctionDeclaration) => void,
+  +'FunctionDeclaration[id]:exit'?: (node: FunctionDeclaration_With_id) => void,
+  +'FunctionDeclaration[params]:exit'?: (
+    node: FunctionDeclaration_With_params,
+  ) => void,
+  +'FunctionDeclaration[body]:exit'?: (
+    node: FunctionDeclaration_With_body,
+  ) => void,
+  +'FunctionDeclaration[typeParameters]:exit'?: (
+    node: FunctionDeclaration_With_typeParameters,
+  ) => void,
+  +'FunctionDeclaration[returnType]:exit'?: (
+    node: FunctionDeclaration_With_returnType,
+  ) => void,
+  +'FunctionDeclaration[predicate]:exit'?: (
+    node: FunctionDeclaration_With_predicate,
+  ) => void,
+  +'FunctionDeclaration[generator]:exit'?: (
+    node: FunctionDeclaration_With_generator,
+  ) => void,
+  +'FunctionDeclaration[async]:exit'?: (
+    node: FunctionDeclaration_With_async,
+  ) => void,
+  +'FunctionExpression:exit'?: (node: FunctionExpression) => void,
+  +'FunctionExpression[id]:exit'?: (node: FunctionExpression_With_id) => void,
+  +'FunctionExpression[params]:exit'?: (
+    node: FunctionExpression_With_params,
+  ) => void,
+  +'FunctionExpression[body]:exit'?: (
+    node: FunctionExpression_With_body,
+  ) => void,
+  +'FunctionExpression[typeParameters]:exit'?: (
+    node: FunctionExpression_With_typeParameters,
+  ) => void,
+  +'FunctionExpression[returnType]:exit'?: (
+    node: FunctionExpression_With_returnType,
+  ) => void,
+  +'FunctionExpression[predicate]:exit'?: (
+    node: FunctionExpression_With_predicate,
+  ) => void,
+  +'FunctionExpression[generator]:exit'?: (
+    node: FunctionExpression_With_generator,
+  ) => void,
+  +'FunctionExpression[async]:exit'?: (
+    node: FunctionExpression_With_async,
+  ) => void,
+  +'FunctionTypeAnnotation:exit'?: (node: FunctionTypeAnnotation) => void,
+  +'FunctionTypeAnnotation[params]:exit'?: (
+    node: FunctionTypeAnnotation_With_params,
+  ) => void,
+  +'FunctionTypeAnnotation[this]:exit'?: (
+    node: FunctionTypeAnnotation_With_this,
+  ) => void,
+  +'FunctionTypeAnnotation[returnType]:exit'?: (
+    node: FunctionTypeAnnotation_With_returnType,
+  ) => void,
+  +'FunctionTypeAnnotation[rest]:exit'?: (
+    node: FunctionTypeAnnotation_With_rest,
+  ) => void,
+  +'FunctionTypeAnnotation[typeParameters]:exit'?: (
+    node: FunctionTypeAnnotation_With_typeParameters,
+  ) => void,
+  +'FunctionTypeParam:exit'?: (node: FunctionTypeParam) => void,
+  +'FunctionTypeParam[name]:exit'?: (node: FunctionTypeParam_With_name) => void,
+  +'FunctionTypeParam[typeAnnotation]:exit'?: (
+    node: FunctionTypeParam_With_typeAnnotation,
+  ) => void,
+  +'FunctionTypeParam[optional]:exit'?: (
+    node: FunctionTypeParam_With_optional,
+  ) => void,
+  +'GenericTypeAnnotation:exit'?: (node: GenericTypeAnnotation) => void,
+  +'GenericTypeAnnotation[id]:exit'?: (
+    node: GenericTypeAnnotation_With_id,
+  ) => void,
+  +'GenericTypeAnnotation[typeParameters]:exit'?: (
+    node: GenericTypeAnnotation_With_typeParameters,
+  ) => void,
+  +'Identifier:exit'?: (node: Identifier) => void,
+  +'Identifier[name]:exit'?: (node: Identifier_With_name) => void,
+  +'Identifier[typeAnnotation]:exit'?: (
+    node: Identifier_With_typeAnnotation,
+  ) => void,
+  +'Identifier[optional]:exit'?: (node: Identifier_With_optional) => void,
+  +'IfStatement:exit'?: (node: IfStatement) => void,
+  +'IfStatement[test]:exit'?: (node: IfStatement_With_test) => void,
+  +'IfStatement[consequent]:exit'?: (node: IfStatement_With_consequent) => void,
+  +'IfStatement[alternate]:exit'?: (node: IfStatement_With_alternate) => void,
+  +'ImportAttribute:exit'?: (node: ImportAttribute) => void,
+  +'ImportAttribute[key]:exit'?: (node: ImportAttribute_With_key) => void,
+  +'ImportAttribute[value]:exit'?: (node: ImportAttribute_With_value) => void,
+  +'ImportDeclaration:exit'?: (node: ImportDeclaration) => void,
+  +'ImportDeclaration[specifiers]:exit'?: (
+    node: ImportDeclaration_With_specifiers,
+  ) => void,
+  +'ImportDeclaration[source]:exit'?: (
+    node: ImportDeclaration_With_source,
+  ) => void,
+  +'ImportDeclaration[assertions]:exit'?: (
+    node: ImportDeclaration_With_assertions,
+  ) => void,
+  +'ImportDeclaration[importKind]:exit'?: (
+    node: ImportDeclaration_With_importKind,
+  ) => void,
+  +'ImportDefaultSpecifier:exit'?: (node: ImportDefaultSpecifier) => void,
+  +'ImportDefaultSpecifier[local]:exit'?: (
+    node: ImportDefaultSpecifier_With_local,
+  ) => void,
+  +'ImportExpression:exit'?: (node: ImportExpression) => void,
+  +'ImportExpression[source]:exit'?: (
+    node: ImportExpression_With_source,
+  ) => void,
+  +'ImportExpression[attributes]:exit'?: (
+    node: ImportExpression_With_attributes,
+  ) => void,
+  +'ImportNamespaceSpecifier:exit'?: (node: ImportNamespaceSpecifier) => void,
+  +'ImportNamespaceSpecifier[local]:exit'?: (
+    node: ImportNamespaceSpecifier_With_local,
+  ) => void,
+  +'ImportSpecifier:exit'?: (node: ImportSpecifier) => void,
+  +'ImportSpecifier[imported]:exit'?: (
+    node: ImportSpecifier_With_imported,
+  ) => void,
+  +'ImportSpecifier[local]:exit'?: (node: ImportSpecifier_With_local) => void,
+  +'ImportSpecifier[importKind]:exit'?: (
+    node: ImportSpecifier_With_importKind,
+  ) => void,
+  +'IndexedAccessType:exit'?: (node: IndexedAccessType) => void,
+  +'IndexedAccessType[objectType]:exit'?: (
+    node: IndexedAccessType_With_objectType,
+  ) => void,
+  +'IndexedAccessType[indexType]:exit'?: (
+    node: IndexedAccessType_With_indexType,
+  ) => void,
+  +'InferredPredicate:exit'?: (node: InferredPredicate) => void,
+  +'InterfaceDeclaration:exit'?: (node: InterfaceDeclaration) => void,
+  +'InterfaceDeclaration[id]:exit'?: (
+    node: InterfaceDeclaration_With_id,
+  ) => void,
+  +'InterfaceDeclaration[typeParameters]:exit'?: (
+    node: InterfaceDeclaration_With_typeParameters,
+  ) => void,
+  +'InterfaceDeclaration[extends]:exit'?: (
+    node: InterfaceDeclaration_With_extends,
+  ) => void,
+  +'InterfaceDeclaration[body]:exit'?: (
+    node: InterfaceDeclaration_With_body,
+  ) => void,
+  +'InterfaceExtends:exit'?: (node: InterfaceExtends) => void,
+  +'InterfaceExtends[id]:exit'?: (node: InterfaceExtends_With_id) => void,
+  +'InterfaceExtends[typeParameters]:exit'?: (
+    node: InterfaceExtends_With_typeParameters,
+  ) => void,
+  +'InterfaceTypeAnnotation:exit'?: (node: InterfaceTypeAnnotation) => void,
+  +'InterfaceTypeAnnotation[extends]:exit'?: (
+    node: InterfaceTypeAnnotation_With_extends,
+  ) => void,
+  +'InterfaceTypeAnnotation[body]:exit'?: (
+    node: InterfaceTypeAnnotation_With_body,
+  ) => void,
+  +'IntersectionTypeAnnotation:exit'?: (
+    node: IntersectionTypeAnnotation,
+  ) => void,
+  +'IntersectionTypeAnnotation[types]:exit'?: (
+    node: IntersectionTypeAnnotation_With_types,
+  ) => void,
+  +'JSXAttribute:exit'?: (node: JSXAttribute) => void,
+  +'JSXAttribute[name]:exit'?: (node: JSXAttribute_With_name) => void,
+  +'JSXAttribute[value]:exit'?: (node: JSXAttribute_With_value) => void,
+  +'JSXClosingElement:exit'?: (node: JSXClosingElement) => void,
+  +'JSXClosingElement[name]:exit'?: (node: JSXClosingElement_With_name) => void,
+  +'JSXClosingFragment:exit'?: (node: JSXClosingFragment) => void,
+  +'JSXElement:exit'?: (node: JSXElement) => void,
+  +'JSXElement[openingElement]:exit'?: (
+    node: JSXElement_With_openingElement,
+  ) => void,
+  +'JSXElement[children]:exit'?: (node: JSXElement_With_children) => void,
+  +'JSXElement[closingElement]:exit'?: (
+    node: JSXElement_With_closingElement,
+  ) => void,
+  +'JSXEmptyExpression:exit'?: (node: JSXEmptyExpression) => void,
+  +'JSXExpressionContainer:exit'?: (node: JSXExpressionContainer) => void,
+  +'JSXExpressionContainer[expression]:exit'?: (
+    node: JSXExpressionContainer_With_expression,
+  ) => void,
+  +'JSXFragment:exit'?: (node: JSXFragment) => void,
+  +'JSXFragment[openingFragment]:exit'?: (
+    node: JSXFragment_With_openingFragment,
+  ) => void,
+  +'JSXFragment[children]:exit'?: (node: JSXFragment_With_children) => void,
+  +'JSXFragment[closingFragment]:exit'?: (
+    node: JSXFragment_With_closingFragment,
+  ) => void,
+  +'JSXIdentifier:exit'?: (node: JSXIdentifier) => void,
+  +'JSXIdentifier[name]:exit'?: (node: JSXIdentifier_With_name) => void,
+  +'JSXMemberExpression:exit'?: (node: JSXMemberExpression) => void,
+  +'JSXMemberExpression[object]:exit'?: (
+    node: JSXMemberExpression_With_object,
+  ) => void,
+  +'JSXMemberExpression[property]:exit'?: (
+    node: JSXMemberExpression_With_property,
+  ) => void,
+  +'JSXNamespacedName:exit'?: (node: JSXNamespacedName) => void,
+  +'JSXNamespacedName[namespace]:exit'?: (
+    node: JSXNamespacedName_With_namespace,
+  ) => void,
+  +'JSXNamespacedName[name]:exit'?: (node: JSXNamespacedName_With_name) => void,
+  +'JSXOpeningElement:exit'?: (node: JSXOpeningElement) => void,
+  +'JSXOpeningElement[name]:exit'?: (node: JSXOpeningElement_With_name) => void,
+  +'JSXOpeningElement[attributes]:exit'?: (
+    node: JSXOpeningElement_With_attributes,
+  ) => void,
+  +'JSXOpeningElement[selfClosing]:exit'?: (
+    node: JSXOpeningElement_With_selfClosing,
+  ) => void,
+  +'JSXOpeningFragment:exit'?: (node: JSXOpeningFragment) => void,
+  +'JSXSpreadAttribute:exit'?: (node: JSXSpreadAttribute) => void,
+  +'JSXSpreadAttribute[argument]:exit'?: (
+    node: JSXSpreadAttribute_With_argument,
+  ) => void,
+  +'JSXSpreadChild:exit'?: (node: JSXSpreadChild) => void,
+  +'JSXSpreadChild[expression]:exit'?: (
+    node: JSXSpreadChild_With_expression,
+  ) => void,
+  +'JSXText:exit'?: (node: JSXText) => void,
+  +'JSXText[value]:exit'?: (node: JSXText_With_value) => void,
+  +'JSXText[raw]:exit'?: (node: JSXText_With_raw) => void,
+  +'LabeledStatement:exit'?: (node: LabeledStatement) => void,
+  +'LabeledStatement[label]:exit'?: (node: LabeledStatement_With_label) => void,
+  +'LabeledStatement[body]:exit'?: (node: LabeledStatement_With_body) => void,
+  +'LogicalExpression:exit'?: (node: LogicalExpression) => void,
+  +'LogicalExpression[left]:exit'?: (node: LogicalExpression_With_left) => void,
+  +'LogicalExpression[right]:exit'?: (
+    node: LogicalExpression_With_right,
+  ) => void,
+  +'LogicalExpression[operator]:exit'?: (
+    node: LogicalExpression_With_operator,
+  ) => void,
+  +'MemberExpression:exit'?: (node: MemberExpression) => void,
+  +'MemberExpression[object]:exit'?: (
+    node: MemberExpression_With_object,
+  ) => void,
+  +'MemberExpression[property]:exit'?: (
+    node: MemberExpression_With_property,
+  ) => void,
+  +'MemberExpression[computed]:exit'?: (
+    node: MemberExpression_With_computed,
+  ) => void,
+  +'MetaProperty:exit'?: (node: MetaProperty) => void,
+  +'MetaProperty[meta]:exit'?: (node: MetaProperty_With_meta) => void,
+  +'MetaProperty[property]:exit'?: (node: MetaProperty_With_property) => void,
+  +'MethodDefinition:exit'?: (node: MethodDefinition) => void,
+  +'MethodDefinition[key]:exit'?: (node: MethodDefinition_With_key) => void,
+  +'MethodDefinition[value]:exit'?: (node: MethodDefinition_With_value) => void,
+  +'MethodDefinition[kind]:exit'?: (node: MethodDefinition_With_kind) => void,
+  +'MethodDefinition[computed]:exit'?: (
+    node: MethodDefinition_With_computed,
+  ) => void,
+  +'MethodDefinition[static]:exit'?: (
+    node: MethodDefinition_With_static,
+  ) => void,
+  +'MixedTypeAnnotation:exit'?: (node: MixedTypeAnnotation) => void,
+  +'NewExpression:exit'?: (node: NewExpression) => void,
+  +'NewExpression[callee]:exit'?: (node: NewExpression_With_callee) => void,
+  +'NewExpression[typeArguments]:exit'?: (
+    node: NewExpression_With_typeArguments,
+  ) => void,
+  +'NewExpression[arguments]:exit'?: (
+    node: NewExpression_With_arguments,
+  ) => void,
+  +'NullableTypeAnnotation:exit'?: (node: NullableTypeAnnotation) => void,
+  +'NullableTypeAnnotation[typeAnnotation]:exit'?: (
+    node: NullableTypeAnnotation_With_typeAnnotation,
+  ) => void,
+  +'NullLiteralTypeAnnotation:exit'?: (node: NullLiteralTypeAnnotation) => void,
+  +'NumberLiteralTypeAnnotation:exit'?: (
+    node: NumberLiteralTypeAnnotation,
+  ) => void,
+  +'NumberLiteralTypeAnnotation[value]:exit'?: (
+    node: NumberLiteralTypeAnnotation_With_value,
+  ) => void,
+  +'NumberLiteralTypeAnnotation[raw]:exit'?: (
+    node: NumberLiteralTypeAnnotation_With_raw,
+  ) => void,
+  +'NumberTypeAnnotation:exit'?: (node: NumberTypeAnnotation) => void,
+  +'ObjectExpression:exit'?: (node: ObjectExpression) => void,
+  +'ObjectExpression[properties]:exit'?: (
+    node: ObjectExpression_With_properties,
+  ) => void,
+  +'ObjectPattern:exit'?: (node: ObjectPattern) => void,
+  +'ObjectPattern[properties]:exit'?: (
+    node: ObjectPattern_With_properties,
+  ) => void,
+  +'ObjectPattern[typeAnnotation]:exit'?: (
+    node: ObjectPattern_With_typeAnnotation,
+  ) => void,
+  +'ObjectTypeAnnotation:exit'?: (node: ObjectTypeAnnotation) => void,
+  +'ObjectTypeAnnotation[properties]:exit'?: (
+    node: ObjectTypeAnnotation_With_properties,
+  ) => void,
+  +'ObjectTypeAnnotation[indexers]:exit'?: (
+    node: ObjectTypeAnnotation_With_indexers,
+  ) => void,
+  +'ObjectTypeAnnotation[callProperties]:exit'?: (
+    node: ObjectTypeAnnotation_With_callProperties,
+  ) => void,
+  +'ObjectTypeAnnotation[internalSlots]:exit'?: (
+    node: ObjectTypeAnnotation_With_internalSlots,
+  ) => void,
+  +'ObjectTypeAnnotation[inexact]:exit'?: (
+    node: ObjectTypeAnnotation_With_inexact,
+  ) => void,
+  +'ObjectTypeAnnotation[exact]:exit'?: (
+    node: ObjectTypeAnnotation_With_exact,
+  ) => void,
+  +'ObjectTypeCallProperty:exit'?: (node: ObjectTypeCallProperty) => void,
+  +'ObjectTypeCallProperty[value]:exit'?: (
+    node: ObjectTypeCallProperty_With_value,
+  ) => void,
+  +'ObjectTypeCallProperty[static]:exit'?: (
+    node: ObjectTypeCallProperty_With_static,
+  ) => void,
+  +'ObjectTypeIndexer:exit'?: (node: ObjectTypeIndexer) => void,
+  +'ObjectTypeIndexer[id]:exit'?: (node: ObjectTypeIndexer_With_id) => void,
+  +'ObjectTypeIndexer[key]:exit'?: (node: ObjectTypeIndexer_With_key) => void,
+  +'ObjectTypeIndexer[value]:exit'?: (
+    node: ObjectTypeIndexer_With_value,
+  ) => void,
+  +'ObjectTypeIndexer[static]:exit'?: (
+    node: ObjectTypeIndexer_With_static,
+  ) => void,
+  +'ObjectTypeIndexer[variance]:exit'?: (
+    node: ObjectTypeIndexer_With_variance,
+  ) => void,
+  +'ObjectTypeInternalSlot:exit'?: (node: ObjectTypeInternalSlot) => void,
+  +'ObjectTypeInternalSlot[id]:exit'?: (
+    node: ObjectTypeInternalSlot_With_id,
+  ) => void,
+  +'ObjectTypeInternalSlot[value]:exit'?: (
+    node: ObjectTypeInternalSlot_With_value,
+  ) => void,
+  +'ObjectTypeInternalSlot[optional]:exit'?: (
+    node: ObjectTypeInternalSlot_With_optional,
+  ) => void,
+  +'ObjectTypeInternalSlot[static]:exit'?: (
+    node: ObjectTypeInternalSlot_With_static,
+  ) => void,
+  +'ObjectTypeInternalSlot[method]:exit'?: (
+    node: ObjectTypeInternalSlot_With_method,
+  ) => void,
+  +'ObjectTypeProperty:exit'?: (node: ObjectTypeProperty) => void,
+  +'ObjectTypeProperty[key]:exit'?: (node: ObjectTypeProperty_With_key) => void,
+  +'ObjectTypeProperty[value]:exit'?: (
+    node: ObjectTypeProperty_With_value,
+  ) => void,
+  +'ObjectTypeProperty[method]:exit'?: (
+    node: ObjectTypeProperty_With_method,
+  ) => void,
+  +'ObjectTypeProperty[optional]:exit'?: (
+    node: ObjectTypeProperty_With_optional,
+  ) => void,
+  +'ObjectTypeProperty[static]:exit'?: (
+    node: ObjectTypeProperty_With_static,
+  ) => void,
+  +'ObjectTypeProperty[proto]:exit'?: (
+    node: ObjectTypeProperty_With_proto,
+  ) => void,
+  +'ObjectTypeProperty[variance]:exit'?: (
+    node: ObjectTypeProperty_With_variance,
+  ) => void,
+  +'ObjectTypeProperty[kind]:exit'?: (
+    node: ObjectTypeProperty_With_kind,
+  ) => void,
+  +'ObjectTypeSpreadProperty:exit'?: (node: ObjectTypeSpreadProperty) => void,
+  +'ObjectTypeSpreadProperty[argument]:exit'?: (
+    node: ObjectTypeSpreadProperty_With_argument,
+  ) => void,
+  +'OpaqueType:exit'?: (node: OpaqueType) => void,
+  +'OpaqueType[id]:exit'?: (node: OpaqueType_With_id) => void,
+  +'OpaqueType[typeParameters]:exit'?: (
+    node: OpaqueType_With_typeParameters,
+  ) => void,
+  +'OpaqueType[impltype]:exit'?: (node: OpaqueType_With_impltype) => void,
+  +'OpaqueType[supertype]:exit'?: (node: OpaqueType_With_supertype) => void,
+  +'OptionalCallExpression:exit'?: (node: OptionalCallExpression) => void,
+  +'OptionalCallExpression[callee]:exit'?: (
+    node: OptionalCallExpression_With_callee,
+  ) => void,
+  +'OptionalCallExpression[typeArguments]:exit'?: (
+    node: OptionalCallExpression_With_typeArguments,
+  ) => void,
+  +'OptionalCallExpression[arguments]:exit'?: (
+    node: OptionalCallExpression_With_arguments,
+  ) => void,
+  +'OptionalCallExpression[optional]:exit'?: (
+    node: OptionalCallExpression_With_optional,
+  ) => void,
+  +'OptionalIndexedAccessType:exit'?: (node: OptionalIndexedAccessType) => void,
+  +'OptionalIndexedAccessType[objectType]:exit'?: (
+    node: OptionalIndexedAccessType_With_objectType,
+  ) => void,
+  +'OptionalIndexedAccessType[indexType]:exit'?: (
+    node: OptionalIndexedAccessType_With_indexType,
+  ) => void,
+  +'OptionalIndexedAccessType[optional]:exit'?: (
+    node: OptionalIndexedAccessType_With_optional,
+  ) => void,
+  +'OptionalMemberExpression:exit'?: (node: OptionalMemberExpression) => void,
+  +'OptionalMemberExpression[object]:exit'?: (
+    node: OptionalMemberExpression_With_object,
+  ) => void,
+  +'OptionalMemberExpression[property]:exit'?: (
+    node: OptionalMemberExpression_With_property,
+  ) => void,
+  +'OptionalMemberExpression[computed]:exit'?: (
+    node: OptionalMemberExpression_With_computed,
+  ) => void,
+  +'OptionalMemberExpression[optional]:exit'?: (
+    node: OptionalMemberExpression_With_optional,
+  ) => void,
+  +'PrivateName:exit'?: (node: PrivateName) => void,
+  +'PrivateName[id]:exit'?: (node: PrivateName_With_id) => void,
+  +'Program:exit'?: (node: Program) => void,
+  +'Program[body]:exit'?: (node: Program_With_body) => void,
+  +'Property:exit'?: (node: Property) => void,
+  +'Property[key]:exit'?: (node: Property_With_key) => void,
+  +'Property[value]:exit'?: (node: Property_With_value) => void,
+  +'Property[kind]:exit'?: (node: Property_With_kind) => void,
+  +'Property[computed]:exit'?: (node: Property_With_computed) => void,
+  +'Property[method]:exit'?: (node: Property_With_method) => void,
+  +'Property[shorthand]:exit'?: (node: Property_With_shorthand) => void,
+  +'QualifiedTypeIdentifier:exit'?: (node: QualifiedTypeIdentifier) => void,
+  +'QualifiedTypeIdentifier[qualification]:exit'?: (
+    node: QualifiedTypeIdentifier_With_qualification,
+  ) => void,
+  +'QualifiedTypeIdentifier[id]:exit'?: (
+    node: QualifiedTypeIdentifier_With_id,
+  ) => void,
+  +'RestElement:exit'?: (node: RestElement) => void,
+  +'RestElement[argument]:exit'?: (node: RestElement_With_argument) => void,
+  +'ReturnStatement:exit'?: (node: ReturnStatement) => void,
+  +'ReturnStatement[argument]:exit'?: (
+    node: ReturnStatement_With_argument,
+  ) => void,
+  +'SequenceExpression:exit'?: (node: SequenceExpression) => void,
+  +'SequenceExpression[expressions]:exit'?: (
+    node: SequenceExpression_With_expressions,
+  ) => void,
+  +'SpreadElement:exit'?: (node: SpreadElement) => void,
+  +'SpreadElement[argument]:exit'?: (node: SpreadElement_With_argument) => void,
+  +'StringLiteralTypeAnnotation:exit'?: (
+    node: StringLiteralTypeAnnotation,
+  ) => void,
+  +'StringLiteralTypeAnnotation[value]:exit'?: (
+    node: StringLiteralTypeAnnotation_With_value,
+  ) => void,
+  +'StringTypeAnnotation:exit'?: (node: StringTypeAnnotation) => void,
+  +'Super:exit'?: (node: Super) => void,
+  +'SwitchCase:exit'?: (node: SwitchCase) => void,
+  +'SwitchCase[test]:exit'?: (node: SwitchCase_With_test) => void,
+  +'SwitchCase[consequent]:exit'?: (node: SwitchCase_With_consequent) => void,
+  +'SwitchStatement:exit'?: (node: SwitchStatement) => void,
+  +'SwitchStatement[discriminant]:exit'?: (
+    node: SwitchStatement_With_discriminant,
+  ) => void,
+  +'SwitchStatement[cases]:exit'?: (node: SwitchStatement_With_cases) => void,
+  +'SymbolTypeAnnotation:exit'?: (node: SymbolTypeAnnotation) => void,
+  +'TaggedTemplateExpression:exit'?: (node: TaggedTemplateExpression) => void,
+  +'TaggedTemplateExpression[tag]:exit'?: (
+    node: TaggedTemplateExpression_With_tag,
+  ) => void,
+  +'TaggedTemplateExpression[quasi]:exit'?: (
+    node: TaggedTemplateExpression_With_quasi,
+  ) => void,
+  +'TemplateElement:exit'?: (node: TemplateElement) => void,
+  +'TemplateElement[tail]:exit'?: (node: TemplateElement_With_tail) => void,
+  +'TemplateElement[cooked]:exit'?: (node: TemplateElement_With_cooked) => void,
+  +'TemplateElement[raw]:exit'?: (node: TemplateElement_With_raw) => void,
+  +'TemplateLiteral:exit'?: (node: TemplateLiteral) => void,
+  +'TemplateLiteral[quasis]:exit'?: (node: TemplateLiteral_With_quasis) => void,
+  +'TemplateLiteral[expressions]:exit'?: (
+    node: TemplateLiteral_With_expressions,
+  ) => void,
+  +'ThisExpression:exit'?: (node: ThisExpression) => void,
+  +'ThisTypeAnnotation:exit'?: (node: ThisTypeAnnotation) => void,
+  +'ThrowStatement:exit'?: (node: ThrowStatement) => void,
+  +'ThrowStatement[argument]:exit'?: (
+    node: ThrowStatement_With_argument,
+  ) => void,
+  +'TryStatement:exit'?: (node: TryStatement) => void,
+  +'TryStatement[block]:exit'?: (node: TryStatement_With_block) => void,
+  +'TryStatement[handler]:exit'?: (node: TryStatement_With_handler) => void,
+  +'TryStatement[finalizer]:exit'?: (node: TryStatement_With_finalizer) => void,
+  +'TupleTypeAnnotation:exit'?: (node: TupleTypeAnnotation) => void,
+  +'TupleTypeAnnotation[types]:exit'?: (
+    node: TupleTypeAnnotation_With_types,
+  ) => void,
+  +'TypeAlias:exit'?: (node: TypeAlias) => void,
+  +'TypeAlias[id]:exit'?: (node: TypeAlias_With_id) => void,
+  +'TypeAlias[typeParameters]:exit'?: (
+    node: TypeAlias_With_typeParameters,
+  ) => void,
+  +'TypeAlias[right]:exit'?: (node: TypeAlias_With_right) => void,
+  +'TypeAnnotation:exit'?: (node: TypeAnnotation) => void,
+  +'TypeAnnotation[typeAnnotation]:exit'?: (
+    node: TypeAnnotation_With_typeAnnotation,
+  ) => void,
+  +'TypeCastExpression:exit'?: (node: TypeCastExpression) => void,
+  +'TypeCastExpression[expression]:exit'?: (
+    node: TypeCastExpression_With_expression,
+  ) => void,
+  +'TypeCastExpression[typeAnnotation]:exit'?: (
+    node: TypeCastExpression_With_typeAnnotation,
+  ) => void,
+  +'TypeofTypeAnnotation:exit'?: (node: TypeofTypeAnnotation) => void,
+  +'TypeofTypeAnnotation[argument]:exit'?: (
+    node: TypeofTypeAnnotation_With_argument,
+  ) => void,
+  +'TypeParameter:exit'?: (node: TypeParameter) => void,
+  +'TypeParameter[name]:exit'?: (node: TypeParameter_With_name) => void,
+  +'TypeParameter[bound]:exit'?: (node: TypeParameter_With_bound) => void,
+  +'TypeParameter[variance]:exit'?: (node: TypeParameter_With_variance) => void,
+  +'TypeParameter[default]:exit'?: (node: TypeParameter_With_default) => void,
+  +'TypeParameterDeclaration:exit'?: (node: TypeParameterDeclaration) => void,
+  +'TypeParameterDeclaration[params]:exit'?: (
+    node: TypeParameterDeclaration_With_params,
+  ) => void,
+  +'TypeParameterInstantiation:exit'?: (
+    node: TypeParameterInstantiation,
+  ) => void,
+  +'TypeParameterInstantiation[params]:exit'?: (
+    node: TypeParameterInstantiation_With_params,
+  ) => void,
+  +'UnaryExpression:exit'?: (node: UnaryExpression) => void,
+  +'UnaryExpression[operator]:exit'?: (
+    node: UnaryExpression_With_operator,
+  ) => void,
+  +'UnaryExpression[argument]:exit'?: (
+    node: UnaryExpression_With_argument,
+  ) => void,
+  +'UnaryExpression[prefix]:exit'?: (node: UnaryExpression_With_prefix) => void,
+  +'UnionTypeAnnotation:exit'?: (node: UnionTypeAnnotation) => void,
+  +'UnionTypeAnnotation[types]:exit'?: (
+    node: UnionTypeAnnotation_With_types,
+  ) => void,
+  +'UpdateExpression:exit'?: (node: UpdateExpression) => void,
+  +'UpdateExpression[operator]:exit'?: (
+    node: UpdateExpression_With_operator,
+  ) => void,
+  +'UpdateExpression[argument]:exit'?: (
+    node: UpdateExpression_With_argument,
+  ) => void,
+  +'UpdateExpression[prefix]:exit'?: (
+    node: UpdateExpression_With_prefix,
+  ) => void,
+  +'VariableDeclaration:exit'?: (node: VariableDeclaration) => void,
+  +'VariableDeclaration[kind]:exit'?: (
+    node: VariableDeclaration_With_kind,
+  ) => void,
+  +'VariableDeclaration[declarations]:exit'?: (
+    node: VariableDeclaration_With_declarations,
+  ) => void,
+  +'VariableDeclarator:exit'?: (node: VariableDeclarator) => void,
+  +'VariableDeclarator[init]:exit'?: (
+    node: VariableDeclarator_With_init,
+  ) => void,
+  +'VariableDeclarator[id]:exit'?: (node: VariableDeclarator_With_id) => void,
+  +'Variance:exit'?: (node: Variance) => void,
+  +'Variance[kind]:exit'?: (node: Variance_With_kind) => void,
+  +'VoidTypeAnnotation:exit'?: (node: VoidTypeAnnotation) => void,
+  +'WhileStatement:exit'?: (node: WhileStatement) => void,
+  +'WhileStatement[body]:exit'?: (node: WhileStatement_With_body) => void,
+  +'WhileStatement[test]:exit'?: (node: WhileStatement_With_test) => void,
+  +'WithStatement:exit'?: (node: WithStatement) => void,
+  +'WithStatement[object]:exit'?: (node: WithStatement_With_object) => void,
+  +'WithStatement[body]:exit'?: (node: WithStatement_With_body) => void,
+  +'YieldExpression:exit'?: (node: YieldExpression) => void,
+  +'YieldExpression[argument]:exit'?: (
+    node: YieldExpression_With_argument,
+  ) => void,
+  +'YieldExpression[delegate]:exit'?: (
+    node: YieldExpression_With_delegate,
+  ) => void,
+  +'Literal:exit'?: (node: Literal) => void,
+  +'*:exit'?: (node: StarSpecialSelector) => void,
+  +':statement:exit'?: (node: StatementSpecialSelector) => void,
+  +':declaration:exit'?: (node: DeclarationSpecialSelector) => void,
+  +':pattern:exit'?: (node: PatternSpecialSelector) => void,
+  +':expression:exit'?: (node: ExpressionSpecialSelector) => void,
+  +':function:exit'?: (node: FunctionSpecialSelector) => void,
+};