/** * Copyright (c) Meta Platforms, Inc. and 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 * @generated */ /* * !!! GENERATED FILE !!! * * Any manual changes to this file will be overwritten. To regenerate run `yarn build`. */ // lint directives to let us do some basic validation of generated files /* eslint no-undef: 'error', no-unused-vars: ['error', {vars: "local"}], no-redeclare: 'error' */ /* global $NonMaybeType, Partial, $ReadOnly, $ReadOnlyArray, $FlowFixMe */ 'use strict'; import type { ESNode, AnyTypeAnnotation, ArrayExpression, ArrayPattern, ArrayTypeAnnotation, ArrowFunctionExpression, AsConstExpression, AsExpression, AssignmentExpression, AssignmentPattern, AwaitExpression, BigIntLiteralTypeAnnotation, BigIntTypeAnnotation, BinaryExpression, BlockStatement, BooleanLiteralTypeAnnotation, BooleanTypeAnnotation, BreakStatement, CallExpression, CatchClause, ChainExpression, ClassBody, ClassDeclaration, ClassExpression, ClassImplements, ComponentDeclaration, ComponentParameter, ComponentTypeAnnotation, ComponentTypeParameter, ConditionalExpression, ConditionalTypeAnnotation, ContinueStatement, DebuggerStatement, DeclareClass, DeclareComponent, DeclaredPredicate, DeclareEnum, DeclareExportAllDeclaration, DeclareExportDeclaration, DeclareFunction, DeclareHook, DeclareInterface, DeclareModule, DeclareModuleExports, DeclareNamespace, DeclareOpaqueType, DeclareTypeAlias, DeclareVariable, DoWhileStatement, EmptyStatement, EmptyTypeAnnotation, EnumBigIntBody, EnumBigIntMember, EnumBooleanBody, EnumBooleanMember, EnumDeclaration, EnumDefaultedMember, EnumNumberBody, EnumNumberMember, EnumStringBody, EnumStringMember, EnumSymbolBody, ExistsTypeAnnotation, ExportAllDeclaration, ExportDefaultDeclaration, ExportNamedDeclaration, ExportSpecifier, ExpressionStatement, ForInStatement, ForOfStatement, ForStatement, FunctionDeclaration, FunctionExpression, FunctionTypeAnnotation, FunctionTypeParam, GenericTypeAnnotation, HookDeclaration, HookTypeAnnotation, Identifier, IfStatement, ImportAttribute, ImportDeclaration, ImportDefaultSpecifier, ImportExpression, ImportNamespaceSpecifier, ImportSpecifier, IndexedAccessType, InferredPredicate, InferTypeAnnotation, InterfaceDeclaration, InterfaceExtends, InterfaceTypeAnnotation, IntersectionTypeAnnotation, JSXAttribute, JSXClosingElement, JSXClosingFragment, JSXElement, JSXEmptyExpression, JSXExpressionContainer, JSXFragment, JSXIdentifier, JSXMemberExpression, JSXNamespacedName, JSXOpeningElement, JSXOpeningFragment, JSXSpreadAttribute, JSXSpreadChild, JSXText, KeyofTypeAnnotation, LabeledStatement, LogicalExpression, MemberExpression, MetaProperty, MethodDefinition, MixedTypeAnnotation, NewExpression, NullableTypeAnnotation, NullLiteralTypeAnnotation, NumberLiteralTypeAnnotation, NumberTypeAnnotation, ObjectExpression, ObjectPattern, ObjectTypeAnnotation, ObjectTypeCallProperty, ObjectTypeIndexer, ObjectTypeInternalSlot, ObjectTypeMappedTypeProperty, ObjectTypeProperty, ObjectTypeSpreadProperty, OpaqueType, OptionalIndexedAccessType, PrivateIdentifier, Program, Property, PropertyDefinition, QualifiedTypeIdentifier, QualifiedTypeofIdentifier, RestElement, ReturnStatement, SequenceExpression, SpreadElement, StringLiteralTypeAnnotation, StringTypeAnnotation, Super, SwitchCase, SwitchStatement, SymbolTypeAnnotation, TaggedTemplateExpression, TemplateElement, TemplateLiteral, ThisExpression, ThisTypeAnnotation, ThrowStatement, TryStatement, TupleTypeAnnotation, TupleTypeLabeledElement, TupleTypeSpreadElement, TypeAlias, TypeAnnotation, TypeCastExpression, TypeofTypeAnnotation, TypeOperator, TypeParameter, TypeParameterDeclaration, TypeParameterInstantiation, TypePredicate, UnaryExpression, UnionTypeAnnotation, UpdateExpression, VariableDeclaration, VariableDeclarator, Variance, VoidTypeAnnotation, WhileStatement, WithStatement, YieldExpression, Literal, } from '../types'; interface ArrayExpression_With_elements extends ArrayExpression { +elements: $NonMaybeType; } interface ArrayExpression_With_trailingComma extends ArrayExpression { +trailingComma: $NonMaybeType; } interface ArrayPattern_With_elements extends ArrayPattern { +elements: $NonMaybeType; } interface ArrayPattern_With_typeAnnotation extends ArrayPattern { +typeAnnotation: $NonMaybeType; } interface ArrayTypeAnnotation_With_elementType extends ArrayTypeAnnotation { +elementType: $NonMaybeType; } interface ArrowFunctionExpression_With_id extends ArrowFunctionExpression { +id: $NonMaybeType; } interface ArrowFunctionExpression_With_params extends ArrowFunctionExpression { +params: $NonMaybeType; } interface ArrowFunctionExpression_With_body extends ArrowFunctionExpression { +body: $NonMaybeType; } interface ArrowFunctionExpression_With_typeParameters extends ArrowFunctionExpression { +typeParameters: $NonMaybeType; } interface ArrowFunctionExpression_With_returnType extends ArrowFunctionExpression { +returnType: $NonMaybeType; } interface ArrowFunctionExpression_With_predicate extends ArrowFunctionExpression { +predicate: $NonMaybeType; } interface ArrowFunctionExpression_With_expression extends ArrowFunctionExpression { +expression: $NonMaybeType; } interface ArrowFunctionExpression_With_async extends ArrowFunctionExpression { +async: $NonMaybeType; } interface AsConstExpression_With_expression extends AsConstExpression { +expression: $NonMaybeType; } interface AsExpression_With_expression extends AsExpression { +expression: $NonMaybeType; } interface AsExpression_With_typeAnnotation extends AsExpression { +typeAnnotation: $NonMaybeType; } interface AssignmentExpression_With_operator extends AssignmentExpression { +operator: $NonMaybeType; } interface AssignmentExpression_With_left extends AssignmentExpression { +left: $NonMaybeType; } interface AssignmentExpression_With_right extends AssignmentExpression { +right: $NonMaybeType; } interface AssignmentPattern_With_left extends AssignmentPattern { +left: $NonMaybeType; } interface AssignmentPattern_With_right extends AssignmentPattern { +right: $NonMaybeType; } interface AwaitExpression_With_argument extends AwaitExpression { +argument: $NonMaybeType; } interface BigIntLiteralTypeAnnotation_With_raw extends BigIntLiteralTypeAnnotation { +raw: $NonMaybeType; } interface BinaryExpression_With_left extends BinaryExpression { +left: $NonMaybeType; } interface BinaryExpression_With_right extends BinaryExpression { +right: $NonMaybeType; } interface BinaryExpression_With_operator extends BinaryExpression { +operator: $NonMaybeType; } interface BlockStatement_With_body extends BlockStatement { +body: $NonMaybeType; } interface BooleanLiteralTypeAnnotation_With_value extends BooleanLiteralTypeAnnotation { +value: $NonMaybeType; } interface BooleanLiteralTypeAnnotation_With_raw extends BooleanLiteralTypeAnnotation { +raw: $NonMaybeType; } interface BreakStatement_With_label extends BreakStatement { +label: $NonMaybeType; } interface CallExpression_With_callee extends CallExpression { +callee: $NonMaybeType; } interface CallExpression_With_typeArguments extends CallExpression { +typeArguments: $NonMaybeType; } interface CallExpression_With_arguments extends CallExpression { +arguments: $NonMaybeType; } interface CatchClause_With_param extends CatchClause { +param: $NonMaybeType; } interface CatchClause_With_body extends CatchClause { +body: $NonMaybeType; } interface ChainExpression_With_expression extends ChainExpression { +expression: $NonMaybeType; } interface ClassBody_With_body extends ClassBody { +body: $NonMaybeType; } interface ClassDeclaration_With_id extends ClassDeclaration { +id: $NonMaybeType; } interface ClassDeclaration_With_typeParameters extends ClassDeclaration { +typeParameters: $NonMaybeType; } interface ClassDeclaration_With_superClass extends ClassDeclaration { +superClass: $NonMaybeType; } interface ClassDeclaration_With_superTypeParameters extends ClassDeclaration { +superTypeParameters: $NonMaybeType; } interface ClassDeclaration_With_implements extends ClassDeclaration { +implements: $NonMaybeType; } interface ClassDeclaration_With_decorators extends ClassDeclaration { +decorators: $NonMaybeType; } interface ClassDeclaration_With_body extends ClassDeclaration { +body: $NonMaybeType; } interface ClassExpression_With_id extends ClassExpression { +id: $NonMaybeType; } interface ClassExpression_With_typeParameters extends ClassExpression { +typeParameters: $NonMaybeType; } interface ClassExpression_With_superClass extends ClassExpression { +superClass: $NonMaybeType; } interface ClassExpression_With_superTypeParameters extends ClassExpression { +superTypeParameters: $NonMaybeType; } interface ClassExpression_With_implements extends ClassExpression { +implements: $NonMaybeType; } interface ClassExpression_With_decorators extends ClassExpression { +decorators: $NonMaybeType; } interface ClassExpression_With_body extends ClassExpression { +body: $NonMaybeType; } interface ClassImplements_With_id extends ClassImplements { +id: $NonMaybeType; } interface ClassImplements_With_typeParameters extends ClassImplements { +typeParameters: $NonMaybeType; } interface ComponentDeclaration_With_id extends ComponentDeclaration { +id: $NonMaybeType; } interface ComponentDeclaration_With_params extends ComponentDeclaration { +params: $NonMaybeType; } interface ComponentDeclaration_With_body extends ComponentDeclaration { +body: $NonMaybeType; } interface ComponentDeclaration_With_typeParameters extends ComponentDeclaration { +typeParameters: $NonMaybeType; } interface ComponentDeclaration_With_rendersType extends ComponentDeclaration { +rendersType: $NonMaybeType; } interface ComponentParameter_With_name extends ComponentParameter { +name: $NonMaybeType; } interface ComponentParameter_With_local extends ComponentParameter { +local: $NonMaybeType; } interface ComponentParameter_With_shorthand extends ComponentParameter { +shorthand: $NonMaybeType; } interface ComponentTypeAnnotation_With_params extends ComponentTypeAnnotation { +params: $NonMaybeType; } interface ComponentTypeAnnotation_With_rest extends ComponentTypeAnnotation { +rest: $NonMaybeType; } interface ComponentTypeAnnotation_With_typeParameters extends ComponentTypeAnnotation { +typeParameters: $NonMaybeType; } interface ComponentTypeAnnotation_With_rendersType extends ComponentTypeAnnotation { +rendersType: $NonMaybeType; } interface ComponentTypeParameter_With_name extends ComponentTypeParameter { +name: $NonMaybeType; } interface ComponentTypeParameter_With_typeAnnotation extends ComponentTypeParameter { +typeAnnotation: $NonMaybeType; } interface ComponentTypeParameter_With_optional extends ComponentTypeParameter { +optional: $NonMaybeType; } interface ConditionalExpression_With_test extends ConditionalExpression { +test: $NonMaybeType; } interface ConditionalExpression_With_alternate extends ConditionalExpression { +alternate: $NonMaybeType; } interface ConditionalExpression_With_consequent extends ConditionalExpression { +consequent: $NonMaybeType; } interface ConditionalTypeAnnotation_With_checkType extends ConditionalTypeAnnotation { +checkType: $NonMaybeType; } interface ConditionalTypeAnnotation_With_extendsType extends ConditionalTypeAnnotation { +extendsType: $NonMaybeType; } interface ConditionalTypeAnnotation_With_trueType extends ConditionalTypeAnnotation { +trueType: $NonMaybeType; } interface ConditionalTypeAnnotation_With_falseType extends ConditionalTypeAnnotation { +falseType: $NonMaybeType; } interface ContinueStatement_With_label extends ContinueStatement { +label: $NonMaybeType; } interface DeclareClass_With_id extends DeclareClass { +id: $NonMaybeType; } interface DeclareClass_With_typeParameters extends DeclareClass { +typeParameters: $NonMaybeType; } interface DeclareClass_With_extends extends DeclareClass { +extends: $NonMaybeType; } interface DeclareClass_With_implements extends DeclareClass { +implements: $NonMaybeType; } interface DeclareClass_With_mixins extends DeclareClass { +mixins: $NonMaybeType; } interface DeclareClass_With_body extends DeclareClass { +body: $NonMaybeType; } interface DeclareComponent_With_id extends DeclareComponent { +id: $NonMaybeType; } interface DeclareComponent_With_params extends DeclareComponent { +params: $NonMaybeType; } interface DeclareComponent_With_rest extends DeclareComponent { +rest: $NonMaybeType; } interface DeclareComponent_With_typeParameters extends DeclareComponent { +typeParameters: $NonMaybeType; } interface DeclareComponent_With_rendersType extends DeclareComponent { +rendersType: $NonMaybeType; } interface DeclaredPredicate_With_value extends DeclaredPredicate { +value: $NonMaybeType; } interface DeclareEnum_With_id extends DeclareEnum { +id: $NonMaybeType; } interface DeclareEnum_With_body extends DeclareEnum { +body: $NonMaybeType; } interface DeclareExportAllDeclaration_With_source extends DeclareExportAllDeclaration { +source: $NonMaybeType; } interface DeclareExportDeclaration_With_declaration extends DeclareExportDeclaration { +declaration: $NonMaybeType; } interface DeclareExportDeclaration_With_specifiers extends DeclareExportDeclaration { +specifiers: $NonMaybeType; } interface DeclareExportDeclaration_With_source extends DeclareExportDeclaration { +source: $NonMaybeType; } interface DeclareExportDeclaration_With_default extends DeclareExportDeclaration { +default: $NonMaybeType; } interface DeclareFunction_With_id extends DeclareFunction { +id: $NonMaybeType; } interface DeclareFunction_With_predicate extends DeclareFunction { +predicate: $NonMaybeType; } interface DeclareHook_With_id extends DeclareHook { +id: $NonMaybeType; } interface DeclareInterface_With_id extends DeclareInterface { +id: $NonMaybeType; } interface DeclareInterface_With_typeParameters extends DeclareInterface { +typeParameters: $NonMaybeType; } interface DeclareInterface_With_extends extends DeclareInterface { +extends: $NonMaybeType; } interface DeclareInterface_With_body extends DeclareInterface { +body: $NonMaybeType; } interface DeclareModule_With_id extends DeclareModule { +id: $NonMaybeType; } interface DeclareModule_With_body extends DeclareModule { +body: $NonMaybeType; } interface DeclareModuleExports_With_typeAnnotation extends DeclareModuleExports { +typeAnnotation: $NonMaybeType; } interface DeclareNamespace_With_id extends DeclareNamespace { +id: $NonMaybeType; } interface DeclareNamespace_With_body extends DeclareNamespace { +body: $NonMaybeType; } interface DeclareOpaqueType_With_id extends DeclareOpaqueType { +id: $NonMaybeType; } interface DeclareOpaqueType_With_typeParameters extends DeclareOpaqueType { +typeParameters: $NonMaybeType; } interface DeclareOpaqueType_With_impltype extends DeclareOpaqueType { +impltype: $NonMaybeType; } interface DeclareOpaqueType_With_supertype extends DeclareOpaqueType { +supertype: $NonMaybeType; } interface DeclareTypeAlias_With_id extends DeclareTypeAlias { +id: $NonMaybeType; } interface DeclareTypeAlias_With_typeParameters extends DeclareTypeAlias { +typeParameters: $NonMaybeType; } interface DeclareTypeAlias_With_right extends DeclareTypeAlias { +right: $NonMaybeType; } interface DeclareVariable_With_id extends DeclareVariable { +id: $NonMaybeType; } interface DeclareVariable_With_kind extends DeclareVariable { +kind: $NonMaybeType; } interface DoWhileStatement_With_body extends DoWhileStatement { +body: $NonMaybeType; } interface DoWhileStatement_With_test extends DoWhileStatement { +test: $NonMaybeType; } interface EnumBigIntBody_With_members extends EnumBigIntBody { +members: $NonMaybeType; } interface EnumBigIntBody_With_explicitType extends EnumBigIntBody { +explicitType: $NonMaybeType; } interface EnumBigIntBody_With_hasUnknownMembers extends EnumBigIntBody { +hasUnknownMembers: $NonMaybeType; } interface EnumBigIntMember_With_id extends EnumBigIntMember { +id: $NonMaybeType; } interface EnumBigIntMember_With_init extends EnumBigIntMember { +init: $NonMaybeType; } interface EnumBooleanBody_With_members extends EnumBooleanBody { +members: $NonMaybeType; } interface EnumBooleanBody_With_explicitType extends EnumBooleanBody { +explicitType: $NonMaybeType; } interface EnumBooleanBody_With_hasUnknownMembers extends EnumBooleanBody { +hasUnknownMembers: $NonMaybeType; } interface EnumBooleanMember_With_id extends EnumBooleanMember { +id: $NonMaybeType; } interface EnumBooleanMember_With_init extends EnumBooleanMember { +init: $NonMaybeType; } interface EnumDeclaration_With_id extends EnumDeclaration { +id: $NonMaybeType; } interface EnumDeclaration_With_body extends EnumDeclaration { +body: $NonMaybeType; } interface EnumDefaultedMember_With_id extends EnumDefaultedMember { +id: $NonMaybeType; } interface EnumNumberBody_With_members extends EnumNumberBody { +members: $NonMaybeType; } interface EnumNumberBody_With_explicitType extends EnumNumberBody { +explicitType: $NonMaybeType; } interface EnumNumberBody_With_hasUnknownMembers extends EnumNumberBody { +hasUnknownMembers: $NonMaybeType; } interface EnumNumberMember_With_id extends EnumNumberMember { +id: $NonMaybeType; } interface EnumNumberMember_With_init extends EnumNumberMember { +init: $NonMaybeType; } interface EnumStringBody_With_members extends EnumStringBody { +members: $NonMaybeType; } interface EnumStringBody_With_explicitType extends EnumStringBody { +explicitType: $NonMaybeType; } interface EnumStringBody_With_hasUnknownMembers extends EnumStringBody { +hasUnknownMembers: $NonMaybeType; } interface EnumStringMember_With_id extends EnumStringMember { +id: $NonMaybeType; } interface EnumStringMember_With_init extends EnumStringMember { +init: $NonMaybeType; } interface EnumSymbolBody_With_members extends EnumSymbolBody { +members: $NonMaybeType; } interface EnumSymbolBody_With_hasUnknownMembers extends EnumSymbolBody { +hasUnknownMembers: $NonMaybeType; } interface ExportAllDeclaration_With_exported extends ExportAllDeclaration { +exported: $NonMaybeType; } interface ExportAllDeclaration_With_source extends ExportAllDeclaration { +source: $NonMaybeType; } interface ExportAllDeclaration_With_exportKind extends ExportAllDeclaration { +exportKind: $NonMaybeType; } interface ExportDefaultDeclaration_With_declaration extends ExportDefaultDeclaration { +declaration: $NonMaybeType; } interface ExportNamedDeclaration_With_declaration extends ExportNamedDeclaration { +declaration: $NonMaybeType; } interface ExportNamedDeclaration_With_specifiers extends ExportNamedDeclaration { +specifiers: $NonMaybeType; } interface ExportNamedDeclaration_With_source extends ExportNamedDeclaration { +source: $NonMaybeType; } interface ExportNamedDeclaration_With_exportKind extends ExportNamedDeclaration { +exportKind: $NonMaybeType; } interface ExportSpecifier_With_exported extends ExportSpecifier { +exported: $NonMaybeType; } interface ExportSpecifier_With_local extends ExportSpecifier { +local: $NonMaybeType; } interface ExpressionStatement_With_expression extends ExpressionStatement { +expression: $NonMaybeType; } interface ExpressionStatement_With_directive extends ExpressionStatement { +directive: $NonMaybeType; } interface ForInStatement_With_left extends ForInStatement { +left: $NonMaybeType; } interface ForInStatement_With_right extends ForInStatement { +right: $NonMaybeType; } interface ForInStatement_With_body extends ForInStatement { +body: $NonMaybeType; } interface ForOfStatement_With_left extends ForOfStatement { +left: $NonMaybeType; } interface ForOfStatement_With_right extends ForOfStatement { +right: $NonMaybeType; } interface ForOfStatement_With_body extends ForOfStatement { +body: $NonMaybeType; } interface ForOfStatement_With_await extends ForOfStatement { +await: $NonMaybeType; } interface ForStatement_With_init extends ForStatement { +init: $NonMaybeType; } interface ForStatement_With_test extends ForStatement { +test: $NonMaybeType; } interface ForStatement_With_update extends ForStatement { +update: $NonMaybeType; } interface ForStatement_With_body extends ForStatement { +body: $NonMaybeType; } interface FunctionDeclaration_With_id extends FunctionDeclaration { +id: $NonMaybeType; } interface FunctionDeclaration_With_params extends FunctionDeclaration { +params: $NonMaybeType; } interface FunctionDeclaration_With_body extends FunctionDeclaration { +body: $NonMaybeType; } interface FunctionDeclaration_With_typeParameters extends FunctionDeclaration { +typeParameters: $NonMaybeType; } interface FunctionDeclaration_With_returnType extends FunctionDeclaration { +returnType: $NonMaybeType; } interface FunctionDeclaration_With_predicate extends FunctionDeclaration { +predicate: $NonMaybeType; } interface FunctionDeclaration_With_generator extends FunctionDeclaration { +generator: $NonMaybeType; } interface FunctionDeclaration_With_async extends FunctionDeclaration { +async: $NonMaybeType; } interface FunctionExpression_With_id extends FunctionExpression { +id: $NonMaybeType; } interface FunctionExpression_With_params extends FunctionExpression { +params: $NonMaybeType; } interface FunctionExpression_With_body extends FunctionExpression { +body: $NonMaybeType; } interface FunctionExpression_With_typeParameters extends FunctionExpression { +typeParameters: $NonMaybeType; } interface FunctionExpression_With_returnType extends FunctionExpression { +returnType: $NonMaybeType; } interface FunctionExpression_With_predicate extends FunctionExpression { +predicate: $NonMaybeType; } interface FunctionExpression_With_generator extends FunctionExpression { +generator: $NonMaybeType; } interface FunctionExpression_With_async extends FunctionExpression { +async: $NonMaybeType; } interface FunctionTypeAnnotation_With_params extends FunctionTypeAnnotation { +params: $NonMaybeType; } interface FunctionTypeAnnotation_With_this extends FunctionTypeAnnotation { +this: $NonMaybeType; } interface FunctionTypeAnnotation_With_returnType extends FunctionTypeAnnotation { +returnType: $NonMaybeType; } interface FunctionTypeAnnotation_With_rest extends FunctionTypeAnnotation { +rest: $NonMaybeType; } interface FunctionTypeAnnotation_With_typeParameters extends FunctionTypeAnnotation { +typeParameters: $NonMaybeType; } interface FunctionTypeParam_With_name extends FunctionTypeParam { +name: $NonMaybeType; } interface FunctionTypeParam_With_typeAnnotation extends FunctionTypeParam { +typeAnnotation: $NonMaybeType; } interface FunctionTypeParam_With_optional extends FunctionTypeParam { +optional: $NonMaybeType; } interface GenericTypeAnnotation_With_id extends GenericTypeAnnotation { +id: $NonMaybeType; } interface GenericTypeAnnotation_With_typeParameters extends GenericTypeAnnotation { +typeParameters: $NonMaybeType; } interface HookDeclaration_With_id extends HookDeclaration { +id: $NonMaybeType; } interface HookDeclaration_With_params extends HookDeclaration { +params: $NonMaybeType; } interface HookDeclaration_With_body extends HookDeclaration { +body: $NonMaybeType; } interface HookDeclaration_With_typeParameters extends HookDeclaration { +typeParameters: $NonMaybeType; } interface HookDeclaration_With_returnType extends HookDeclaration { +returnType: $NonMaybeType; } interface HookTypeAnnotation_With_params extends HookTypeAnnotation { +params: $NonMaybeType; } interface HookTypeAnnotation_With_returnType extends HookTypeAnnotation { +returnType: $NonMaybeType; } interface HookTypeAnnotation_With_rest extends HookTypeAnnotation { +rest: $NonMaybeType; } interface HookTypeAnnotation_With_typeParameters extends HookTypeAnnotation { +typeParameters: $NonMaybeType; } interface Identifier_With_name extends Identifier { +name: $NonMaybeType; } interface Identifier_With_typeAnnotation extends Identifier { +typeAnnotation: $NonMaybeType; } interface Identifier_With_optional extends Identifier { +optional: $NonMaybeType; } interface IfStatement_With_test extends IfStatement { +test: $NonMaybeType; } interface IfStatement_With_consequent extends IfStatement { +consequent: $NonMaybeType; } interface IfStatement_With_alternate extends IfStatement { +alternate: $NonMaybeType; } interface ImportAttribute_With_key extends ImportAttribute { +key: $NonMaybeType; } interface ImportAttribute_With_value extends ImportAttribute { +value: $NonMaybeType; } interface ImportDeclaration_With_specifiers extends ImportDeclaration { +specifiers: $NonMaybeType; } interface ImportDeclaration_With_source extends ImportDeclaration { +source: $NonMaybeType; } interface ImportDeclaration_With_assertions extends ImportDeclaration { +assertions: $NonMaybeType; } interface ImportDeclaration_With_importKind extends ImportDeclaration { +importKind: $NonMaybeType; } interface ImportDefaultSpecifier_With_local extends ImportDefaultSpecifier { +local: $NonMaybeType; } interface ImportExpression_With_source extends ImportExpression { +source: $NonMaybeType; } interface ImportExpression_With_attributes extends ImportExpression { +attributes: $NonMaybeType; } interface ImportNamespaceSpecifier_With_local extends ImportNamespaceSpecifier { +local: $NonMaybeType; } interface ImportSpecifier_With_imported extends ImportSpecifier { +imported: $NonMaybeType; } interface ImportSpecifier_With_local extends ImportSpecifier { +local: $NonMaybeType; } interface ImportSpecifier_With_importKind extends ImportSpecifier { +importKind: $NonMaybeType; } interface IndexedAccessType_With_objectType extends IndexedAccessType { +objectType: $NonMaybeType; } interface IndexedAccessType_With_indexType extends IndexedAccessType { +indexType: $NonMaybeType; } interface InferTypeAnnotation_With_typeParameter extends InferTypeAnnotation { +typeParameter: $NonMaybeType; } interface InterfaceDeclaration_With_id extends InterfaceDeclaration { +id: $NonMaybeType; } interface InterfaceDeclaration_With_typeParameters extends InterfaceDeclaration { +typeParameters: $NonMaybeType; } interface InterfaceDeclaration_With_extends extends InterfaceDeclaration { +extends: $NonMaybeType; } interface InterfaceDeclaration_With_body extends InterfaceDeclaration { +body: $NonMaybeType; } interface InterfaceExtends_With_id extends InterfaceExtends { +id: $NonMaybeType; } interface InterfaceExtends_With_typeParameters extends InterfaceExtends { +typeParameters: $NonMaybeType; } interface InterfaceTypeAnnotation_With_extends extends InterfaceTypeAnnotation { +extends: $NonMaybeType; } interface InterfaceTypeAnnotation_With_body extends InterfaceTypeAnnotation { +body: $NonMaybeType; } interface IntersectionTypeAnnotation_With_types extends IntersectionTypeAnnotation { +types: $NonMaybeType; } interface JSXAttribute_With_name extends JSXAttribute { +name: $NonMaybeType; } interface JSXAttribute_With_value extends JSXAttribute { +value: $NonMaybeType; } interface JSXClosingElement_With_name extends JSXClosingElement { +name: $NonMaybeType; } interface JSXElement_With_openingElement extends JSXElement { +openingElement: $NonMaybeType; } interface JSXElement_With_children extends JSXElement { +children: $NonMaybeType; } interface JSXElement_With_closingElement extends JSXElement { +closingElement: $NonMaybeType; } interface JSXExpressionContainer_With_expression extends JSXExpressionContainer { +expression: $NonMaybeType; } interface JSXFragment_With_openingFragment extends JSXFragment { +openingFragment: $NonMaybeType; } interface JSXFragment_With_children extends JSXFragment { +children: $NonMaybeType; } interface JSXFragment_With_closingFragment extends JSXFragment { +closingFragment: $NonMaybeType; } interface JSXIdentifier_With_name extends JSXIdentifier { +name: $NonMaybeType; } interface JSXMemberExpression_With_object extends JSXMemberExpression { +object: $NonMaybeType; } interface JSXMemberExpression_With_property extends JSXMemberExpression { +property: $NonMaybeType; } interface JSXNamespacedName_With_namespace extends JSXNamespacedName { +namespace: $NonMaybeType; } interface JSXNamespacedName_With_name extends JSXNamespacedName { +name: $NonMaybeType; } interface JSXOpeningElement_With_name extends JSXOpeningElement { +name: $NonMaybeType; } interface JSXOpeningElement_With_attributes extends JSXOpeningElement { +attributes: $NonMaybeType; } interface JSXOpeningElement_With_selfClosing extends JSXOpeningElement { +selfClosing: $NonMaybeType; } interface JSXOpeningElement_With_typeArguments extends JSXOpeningElement { +typeArguments: $NonMaybeType; } interface JSXSpreadAttribute_With_argument extends JSXSpreadAttribute { +argument: $NonMaybeType; } interface JSXSpreadChild_With_expression extends JSXSpreadChild { +expression: $NonMaybeType; } interface JSXText_With_value extends JSXText { +value: $NonMaybeType; } interface JSXText_With_raw extends JSXText { +raw: $NonMaybeType; } interface KeyofTypeAnnotation_With_argument extends KeyofTypeAnnotation { +argument: $NonMaybeType; } interface LabeledStatement_With_label extends LabeledStatement { +label: $NonMaybeType; } interface LabeledStatement_With_body extends LabeledStatement { +body: $NonMaybeType; } interface LogicalExpression_With_left extends LogicalExpression { +left: $NonMaybeType; } interface LogicalExpression_With_right extends LogicalExpression { +right: $NonMaybeType; } interface LogicalExpression_With_operator extends LogicalExpression { +operator: $NonMaybeType; } interface MemberExpression_With_object extends MemberExpression { +object: $NonMaybeType; } interface MemberExpression_With_property extends MemberExpression { +property: $NonMaybeType; } interface MemberExpression_With_computed extends MemberExpression { +computed: $NonMaybeType; } interface MetaProperty_With_meta extends MetaProperty { +meta: $NonMaybeType; } interface MetaProperty_With_property extends MetaProperty { +property: $NonMaybeType; } interface MethodDefinition_With_key extends MethodDefinition { +key: $NonMaybeType; } interface MethodDefinition_With_value extends MethodDefinition { +value: $NonMaybeType; } interface MethodDefinition_With_kind extends MethodDefinition { +kind: $NonMaybeType; } interface MethodDefinition_With_computed extends MethodDefinition { +computed: $NonMaybeType; } interface MethodDefinition_With_static extends MethodDefinition { +static: $NonMaybeType; } interface NewExpression_With_callee extends NewExpression { +callee: $NonMaybeType; } interface NewExpression_With_typeArguments extends NewExpression { +typeArguments: $NonMaybeType; } interface NewExpression_With_arguments extends NewExpression { +arguments: $NonMaybeType; } interface NullableTypeAnnotation_With_typeAnnotation extends NullableTypeAnnotation { +typeAnnotation: $NonMaybeType; } interface NumberLiteralTypeAnnotation_With_value extends NumberLiteralTypeAnnotation { +value: $NonMaybeType; } interface NumberLiteralTypeAnnotation_With_raw extends NumberLiteralTypeAnnotation { +raw: $NonMaybeType; } interface ObjectExpression_With_properties extends ObjectExpression { +properties: $NonMaybeType; } interface ObjectPattern_With_properties extends ObjectPattern { +properties: $NonMaybeType; } interface ObjectPattern_With_typeAnnotation extends ObjectPattern { +typeAnnotation: $NonMaybeType; } interface ObjectTypeAnnotation_With_properties extends ObjectTypeAnnotation { +properties: $NonMaybeType; } interface ObjectTypeAnnotation_With_indexers extends ObjectTypeAnnotation { +indexers: $NonMaybeType; } interface ObjectTypeAnnotation_With_callProperties extends ObjectTypeAnnotation { +callProperties: $NonMaybeType; } interface ObjectTypeAnnotation_With_internalSlots extends ObjectTypeAnnotation { +internalSlots: $NonMaybeType; } interface ObjectTypeAnnotation_With_inexact extends ObjectTypeAnnotation { +inexact: $NonMaybeType; } interface ObjectTypeAnnotation_With_exact extends ObjectTypeAnnotation { +exact: $NonMaybeType; } interface ObjectTypeCallProperty_With_value extends ObjectTypeCallProperty { +value: $NonMaybeType; } interface ObjectTypeCallProperty_With_static extends ObjectTypeCallProperty { +static: $NonMaybeType; } interface ObjectTypeIndexer_With_id extends ObjectTypeIndexer { +id: $NonMaybeType; } interface ObjectTypeIndexer_With_key extends ObjectTypeIndexer { +key: $NonMaybeType; } interface ObjectTypeIndexer_With_value extends ObjectTypeIndexer { +value: $NonMaybeType; } interface ObjectTypeIndexer_With_static extends ObjectTypeIndexer { +static: $NonMaybeType; } interface ObjectTypeIndexer_With_variance extends ObjectTypeIndexer { +variance: $NonMaybeType; } interface ObjectTypeInternalSlot_With_id extends ObjectTypeInternalSlot { +id: $NonMaybeType; } interface ObjectTypeInternalSlot_With_value extends ObjectTypeInternalSlot { +value: $NonMaybeType; } interface ObjectTypeInternalSlot_With_optional extends ObjectTypeInternalSlot { +optional: $NonMaybeType; } interface ObjectTypeInternalSlot_With_static extends ObjectTypeInternalSlot { +static: $NonMaybeType; } interface ObjectTypeInternalSlot_With_method extends ObjectTypeInternalSlot { +method: $NonMaybeType; } interface ObjectTypeMappedTypeProperty_With_keyTparam extends ObjectTypeMappedTypeProperty { +keyTparam: $NonMaybeType; } interface ObjectTypeMappedTypeProperty_With_propType extends ObjectTypeMappedTypeProperty { +propType: $NonMaybeType; } interface ObjectTypeMappedTypeProperty_With_sourceType extends ObjectTypeMappedTypeProperty { +sourceType: $NonMaybeType; } interface ObjectTypeMappedTypeProperty_With_variance extends ObjectTypeMappedTypeProperty { +variance: $NonMaybeType; } interface ObjectTypeMappedTypeProperty_With_optional extends ObjectTypeMappedTypeProperty { +optional: $NonMaybeType; } interface ObjectTypeProperty_With_key extends ObjectTypeProperty { +key: $NonMaybeType; } interface ObjectTypeProperty_With_value extends ObjectTypeProperty { +value: $NonMaybeType; } interface ObjectTypeProperty_With_method extends ObjectTypeProperty { +method: $NonMaybeType; } interface ObjectTypeProperty_With_optional extends ObjectTypeProperty { +optional: $NonMaybeType; } interface ObjectTypeProperty_With_static extends ObjectTypeProperty { +static: $NonMaybeType; } interface ObjectTypeProperty_With_proto extends ObjectTypeProperty { +proto: $NonMaybeType; } interface ObjectTypeProperty_With_variance extends ObjectTypeProperty { +variance: $NonMaybeType; } interface ObjectTypeProperty_With_kind extends ObjectTypeProperty { +kind: $NonMaybeType; } interface ObjectTypeSpreadProperty_With_argument extends ObjectTypeSpreadProperty { +argument: $NonMaybeType; } interface OpaqueType_With_id extends OpaqueType { +id: $NonMaybeType; } interface OpaqueType_With_typeParameters extends OpaqueType { +typeParameters: $NonMaybeType; } interface OpaqueType_With_impltype extends OpaqueType { +impltype: $NonMaybeType; } interface OpaqueType_With_supertype extends OpaqueType { +supertype: $NonMaybeType; } interface OptionalIndexedAccessType_With_objectType extends OptionalIndexedAccessType { +objectType: $NonMaybeType; } interface OptionalIndexedAccessType_With_indexType extends OptionalIndexedAccessType { +indexType: $NonMaybeType; } interface OptionalIndexedAccessType_With_optional extends OptionalIndexedAccessType { +optional: $NonMaybeType; } interface PrivateIdentifier_With_name extends PrivateIdentifier { +name: $NonMaybeType; } interface Program_With_body extends Program { +body: $NonMaybeType; } interface Property_With_key extends Property { +key: $NonMaybeType; } interface Property_With_value extends Property { +value: $NonMaybeType; } interface Property_With_kind extends Property { +kind: $NonMaybeType; } interface Property_With_computed extends Property { +computed: $NonMaybeType; } interface Property_With_method extends Property { +method: $NonMaybeType; } interface Property_With_shorthand extends Property { +shorthand: $NonMaybeType; } interface PropertyDefinition_With_key extends PropertyDefinition { +key: $NonMaybeType; } interface PropertyDefinition_With_value extends PropertyDefinition { +value: $NonMaybeType; } interface PropertyDefinition_With_computed extends PropertyDefinition { +computed: $NonMaybeType; } interface PropertyDefinition_With_static extends PropertyDefinition { +static: $NonMaybeType; } interface PropertyDefinition_With_declare extends PropertyDefinition { +declare: $NonMaybeType; } interface PropertyDefinition_With_optional extends PropertyDefinition { +optional: $NonMaybeType; } interface PropertyDefinition_With_variance extends PropertyDefinition { +variance: $NonMaybeType; } interface PropertyDefinition_With_typeAnnotation extends PropertyDefinition { +typeAnnotation: $NonMaybeType; } interface PropertyDefinition_With_tsModifiers extends PropertyDefinition { +tsModifiers: $NonMaybeType; } interface QualifiedTypeIdentifier_With_qualification extends QualifiedTypeIdentifier { +qualification: $NonMaybeType; } interface QualifiedTypeIdentifier_With_id extends QualifiedTypeIdentifier { +id: $NonMaybeType; } interface QualifiedTypeofIdentifier_With_qualification extends QualifiedTypeofIdentifier { +qualification: $NonMaybeType; } interface QualifiedTypeofIdentifier_With_id extends QualifiedTypeofIdentifier { +id: $NonMaybeType; } interface RestElement_With_argument extends RestElement { +argument: $NonMaybeType; } interface ReturnStatement_With_argument extends ReturnStatement { +argument: $NonMaybeType; } interface SequenceExpression_With_expressions extends SequenceExpression { +expressions: $NonMaybeType; } interface SpreadElement_With_argument extends SpreadElement { +argument: $NonMaybeType; } interface StringLiteralTypeAnnotation_With_value extends StringLiteralTypeAnnotation { +value: $NonMaybeType; } interface StringLiteralTypeAnnotation_With_raw extends StringLiteralTypeAnnotation { +raw: $NonMaybeType; } interface SwitchCase_With_test extends SwitchCase { +test: $NonMaybeType; } interface SwitchCase_With_consequent extends SwitchCase { +consequent: $NonMaybeType; } interface SwitchStatement_With_discriminant extends SwitchStatement { +discriminant: $NonMaybeType; } interface SwitchStatement_With_cases extends SwitchStatement { +cases: $NonMaybeType; } interface TaggedTemplateExpression_With_tag extends TaggedTemplateExpression { +tag: $NonMaybeType; } interface TaggedTemplateExpression_With_quasi extends TaggedTemplateExpression { +quasi: $NonMaybeType; } interface TemplateElement_With_tail extends TemplateElement { +tail: $NonMaybeType; } interface TemplateElement_With_cooked extends TemplateElement { +cooked: $NonMaybeType; } interface TemplateElement_With_raw extends TemplateElement { +raw: $NonMaybeType; } interface TemplateLiteral_With_quasis extends TemplateLiteral { +quasis: $NonMaybeType; } interface TemplateLiteral_With_expressions extends TemplateLiteral { +expressions: $NonMaybeType; } interface ThrowStatement_With_argument extends ThrowStatement { +argument: $NonMaybeType; } interface TryStatement_With_block extends TryStatement { +block: $NonMaybeType; } interface TryStatement_With_handler extends TryStatement { +handler: $NonMaybeType; } interface TryStatement_With_finalizer extends TryStatement { +finalizer: $NonMaybeType; } interface TupleTypeAnnotation_With_types extends TupleTypeAnnotation { +types: $NonMaybeType; } interface TupleTypeAnnotation_With_inexact extends TupleTypeAnnotation { +inexact: $NonMaybeType; } interface TupleTypeLabeledElement_With_label extends TupleTypeLabeledElement { +label: $NonMaybeType; } interface TupleTypeLabeledElement_With_elementType extends TupleTypeLabeledElement { +elementType: $NonMaybeType; } interface TupleTypeLabeledElement_With_optional extends TupleTypeLabeledElement { +optional: $NonMaybeType; } interface TupleTypeLabeledElement_With_variance extends TupleTypeLabeledElement { +variance: $NonMaybeType; } interface TupleTypeSpreadElement_With_label extends TupleTypeSpreadElement { +label: $NonMaybeType; } interface TupleTypeSpreadElement_With_typeAnnotation extends TupleTypeSpreadElement { +typeAnnotation: $NonMaybeType; } interface TypeAlias_With_id extends TypeAlias { +id: $NonMaybeType; } interface TypeAlias_With_typeParameters extends TypeAlias { +typeParameters: $NonMaybeType; } interface TypeAlias_With_right extends TypeAlias { +right: $NonMaybeType; } interface TypeAnnotation_With_typeAnnotation extends TypeAnnotation { +typeAnnotation: $NonMaybeType; } interface TypeCastExpression_With_expression extends TypeCastExpression { +expression: $NonMaybeType; } interface TypeCastExpression_With_typeAnnotation extends TypeCastExpression { +typeAnnotation: $NonMaybeType; } interface TypeofTypeAnnotation_With_argument extends TypeofTypeAnnotation { +argument: $NonMaybeType; } interface TypeofTypeAnnotation_With_typeArguments extends TypeofTypeAnnotation { +typeArguments: $NonMaybeType; } interface TypeOperator_With_operator extends TypeOperator { +operator: $NonMaybeType; } interface TypeOperator_With_typeAnnotation extends TypeOperator { +typeAnnotation: $NonMaybeType; } interface TypeParameter_With_name extends TypeParameter { +name: $NonMaybeType; } interface TypeParameter_With_bound extends TypeParameter { +bound: $NonMaybeType; } interface TypeParameter_With_variance extends TypeParameter { +variance: $NonMaybeType; } interface TypeParameter_With_default extends TypeParameter { +default: $NonMaybeType; } interface TypeParameter_With_usesExtendsBound extends TypeParameter { +usesExtendsBound: $NonMaybeType; } interface TypeParameterDeclaration_With_params extends TypeParameterDeclaration { +params: $NonMaybeType; } interface TypeParameterInstantiation_With_params extends TypeParameterInstantiation { +params: $NonMaybeType; } interface TypePredicate_With_parameterName extends TypePredicate { +parameterName: $NonMaybeType; } interface TypePredicate_With_typeAnnotation extends TypePredicate { +typeAnnotation: $NonMaybeType; } interface TypePredicate_With_kind extends TypePredicate { +kind: $NonMaybeType; } interface UnaryExpression_With_operator extends UnaryExpression { +operator: $NonMaybeType; } interface UnaryExpression_With_argument extends UnaryExpression { +argument: $NonMaybeType; } interface UnaryExpression_With_prefix extends UnaryExpression { +prefix: $NonMaybeType; } interface UnionTypeAnnotation_With_types extends UnionTypeAnnotation { +types: $NonMaybeType; } interface UpdateExpression_With_operator extends UpdateExpression { +operator: $NonMaybeType; } interface UpdateExpression_With_argument extends UpdateExpression { +argument: $NonMaybeType; } interface UpdateExpression_With_prefix extends UpdateExpression { +prefix: $NonMaybeType; } interface VariableDeclaration_With_kind extends VariableDeclaration { +kind: $NonMaybeType; } interface VariableDeclaration_With_declarations extends VariableDeclaration { +declarations: $NonMaybeType; } interface VariableDeclarator_With_init extends VariableDeclarator { +init: $NonMaybeType; } interface VariableDeclarator_With_id extends VariableDeclarator { +id: $NonMaybeType; } interface Variance_With_kind extends Variance { +kind: $NonMaybeType; } interface WhileStatement_With_body extends WhileStatement { +body: $NonMaybeType; } interface WhileStatement_With_test extends WhileStatement { +test: $NonMaybeType; } interface WithStatement_With_object extends WithStatement { +object: $NonMaybeType; } interface WithStatement_With_body extends WithStatement { +body: $NonMaybeType; } interface YieldExpression_With_argument extends YieldExpression { +argument: $NonMaybeType; } interface YieldExpression_With_delegate extends YieldExpression { +delegate: $NonMaybeType; } 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 | ComponentDeclaration | DeclareExportAllDeclaration | DeclareExportDeclaration | EnumDeclaration | ExportAllDeclaration | ExportDefaultDeclaration | ExportNamedDeclaration | FunctionDeclaration | HookDeclaration | ImportDeclaration | InterfaceDeclaration | TypeParameterDeclaration | VariableDeclaration; type PatternSpecialSelector = ArrayPattern | AssignmentPattern | ObjectPattern; type ExpressionSpecialSelector = | Identifier | MetaProperty | ArrayExpression | ArrowFunctionExpression | AsConstExpression | AsExpression | AssignmentExpression | AwaitExpression | BinaryExpression | CallExpression | ChainExpression | ClassExpression | ConditionalExpression | FunctionExpression | ImportExpression | JSXEmptyExpression | JSXMemberExpression | LogicalExpression | MemberExpression | NewExpression | ObjectExpression | 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, +AsConstExpression?: (node: AsConstExpression) => void, +'AsConstExpression[expression]'?: ( node: AsConstExpression_With_expression, ) => void, +AsExpression?: (node: AsExpression) => void, +'AsExpression[expression]'?: (node: AsExpression_With_expression) => void, +'AsExpression[typeAnnotation]'?: ( node: AsExpression_With_typeAnnotation, ) => 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, +BigIntLiteralTypeAnnotation?: (node: BigIntLiteralTypeAnnotation) => void, +'BigIntLiteralTypeAnnotation[raw]'?: ( node: BigIntLiteralTypeAnnotation_With_raw, ) => void, +BigIntTypeAnnotation?: (node: BigIntTypeAnnotation) => 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, +ChainExpression?: (node: ChainExpression) => void, +'ChainExpression[expression]'?: ( node: ChainExpression_With_expression, ) => 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, +ComponentDeclaration?: (node: ComponentDeclaration) => void, +'ComponentDeclaration[id]'?: (node: ComponentDeclaration_With_id) => void, +'ComponentDeclaration[params]'?: ( node: ComponentDeclaration_With_params, ) => void, +'ComponentDeclaration[body]'?: ( node: ComponentDeclaration_With_body, ) => void, +'ComponentDeclaration[typeParameters]'?: ( node: ComponentDeclaration_With_typeParameters, ) => void, +'ComponentDeclaration[rendersType]'?: ( node: ComponentDeclaration_With_rendersType, ) => void, +ComponentParameter?: (node: ComponentParameter) => void, +'ComponentParameter[name]'?: (node: ComponentParameter_With_name) => void, +'ComponentParameter[local]'?: (node: ComponentParameter_With_local) => void, +'ComponentParameter[shorthand]'?: ( node: ComponentParameter_With_shorthand, ) => void, +ComponentTypeAnnotation?: (node: ComponentTypeAnnotation) => void, +'ComponentTypeAnnotation[params]'?: ( node: ComponentTypeAnnotation_With_params, ) => void, +'ComponentTypeAnnotation[rest]'?: ( node: ComponentTypeAnnotation_With_rest, ) => void, +'ComponentTypeAnnotation[typeParameters]'?: ( node: ComponentTypeAnnotation_With_typeParameters, ) => void, +'ComponentTypeAnnotation[rendersType]'?: ( node: ComponentTypeAnnotation_With_rendersType, ) => void, +ComponentTypeParameter?: (node: ComponentTypeParameter) => void, +'ComponentTypeParameter[name]'?: ( node: ComponentTypeParameter_With_name, ) => void, +'ComponentTypeParameter[typeAnnotation]'?: ( node: ComponentTypeParameter_With_typeAnnotation, ) => void, +'ComponentTypeParameter[optional]'?: ( node: ComponentTypeParameter_With_optional, ) => 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, +ConditionalTypeAnnotation?: (node: ConditionalTypeAnnotation) => void, +'ConditionalTypeAnnotation[checkType]'?: ( node: ConditionalTypeAnnotation_With_checkType, ) => void, +'ConditionalTypeAnnotation[extendsType]'?: ( node: ConditionalTypeAnnotation_With_extendsType, ) => void, +'ConditionalTypeAnnotation[trueType]'?: ( node: ConditionalTypeAnnotation_With_trueType, ) => void, +'ConditionalTypeAnnotation[falseType]'?: ( node: ConditionalTypeAnnotation_With_falseType, ) => 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, +DeclareComponent?: (node: DeclareComponent) => void, +'DeclareComponent[id]'?: (node: DeclareComponent_With_id) => void, +'DeclareComponent[params]'?: (node: DeclareComponent_With_params) => void, +'DeclareComponent[rest]'?: (node: DeclareComponent_With_rest) => void, +'DeclareComponent[typeParameters]'?: ( node: DeclareComponent_With_typeParameters, ) => void, +'DeclareComponent[rendersType]'?: ( node: DeclareComponent_With_rendersType, ) => void, +DeclaredPredicate?: (node: DeclaredPredicate) => void, +'DeclaredPredicate[value]'?: (node: DeclaredPredicate_With_value) => void, +DeclareEnum?: (node: DeclareEnum) => void, +'DeclareEnum[id]'?: (node: DeclareEnum_With_id) => void, +'DeclareEnum[body]'?: (node: DeclareEnum_With_body) => 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, +DeclareHook?: (node: DeclareHook) => void, +'DeclareHook[id]'?: (node: DeclareHook_With_id) => 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, +DeclareModuleExports?: (node: DeclareModuleExports) => void, +'DeclareModuleExports[typeAnnotation]'?: ( node: DeclareModuleExports_With_typeAnnotation, ) => void, +DeclareNamespace?: (node: DeclareNamespace) => void, +'DeclareNamespace[id]'?: (node: DeclareNamespace_With_id) => void, +'DeclareNamespace[body]'?: (node: DeclareNamespace_With_body) => 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, +'DeclareVariable[kind]'?: (node: DeclareVariable_With_kind) => 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, +EnumBigIntBody?: (node: EnumBigIntBody) => void, +'EnumBigIntBody[members]'?: (node: EnumBigIntBody_With_members) => void, +'EnumBigIntBody[explicitType]'?: ( node: EnumBigIntBody_With_explicitType, ) => void, +'EnumBigIntBody[hasUnknownMembers]'?: ( node: EnumBigIntBody_With_hasUnknownMembers, ) => void, +EnumBigIntMember?: (node: EnumBigIntMember) => void, +'EnumBigIntMember[id]'?: (node: EnumBigIntMember_With_id) => void, +'EnumBigIntMember[init]'?: (node: EnumBigIntMember_With_init) => 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[exported]'?: ( node: ExportAllDeclaration_With_exported, ) => 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, +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, +HookDeclaration?: (node: HookDeclaration) => void, +'HookDeclaration[id]'?: (node: HookDeclaration_With_id) => void, +'HookDeclaration[params]'?: (node: HookDeclaration_With_params) => void, +'HookDeclaration[body]'?: (node: HookDeclaration_With_body) => void, +'HookDeclaration[typeParameters]'?: ( node: HookDeclaration_With_typeParameters, ) => void, +'HookDeclaration[returnType]'?: ( node: HookDeclaration_With_returnType, ) => void, +HookTypeAnnotation?: (node: HookTypeAnnotation) => void, +'HookTypeAnnotation[params]'?: ( node: HookTypeAnnotation_With_params, ) => void, +'HookTypeAnnotation[returnType]'?: ( node: HookTypeAnnotation_With_returnType, ) => void, +'HookTypeAnnotation[rest]'?: (node: HookTypeAnnotation_With_rest) => void, +'HookTypeAnnotation[typeParameters]'?: ( node: HookTypeAnnotation_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, +InferTypeAnnotation?: (node: InferTypeAnnotation) => void, +'InferTypeAnnotation[typeParameter]'?: ( node: InferTypeAnnotation_With_typeParameter, ) => 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, +'JSXOpeningElement[typeArguments]'?: ( node: JSXOpeningElement_With_typeArguments, ) => 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, +KeyofTypeAnnotation?: (node: KeyofTypeAnnotation) => void, +'KeyofTypeAnnotation[argument]'?: ( node: KeyofTypeAnnotation_With_argument, ) => 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, +ObjectTypeMappedTypeProperty?: (node: ObjectTypeMappedTypeProperty) => void, +'ObjectTypeMappedTypeProperty[keyTparam]'?: ( node: ObjectTypeMappedTypeProperty_With_keyTparam, ) => void, +'ObjectTypeMappedTypeProperty[propType]'?: ( node: ObjectTypeMappedTypeProperty_With_propType, ) => void, +'ObjectTypeMappedTypeProperty[sourceType]'?: ( node: ObjectTypeMappedTypeProperty_With_sourceType, ) => void, +'ObjectTypeMappedTypeProperty[variance]'?: ( node: ObjectTypeMappedTypeProperty_With_variance, ) => void, +'ObjectTypeMappedTypeProperty[optional]'?: ( node: ObjectTypeMappedTypeProperty_With_optional, ) => 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, +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, +PrivateIdentifier?: (node: PrivateIdentifier) => void, +'PrivateIdentifier[name]'?: (node: PrivateIdentifier_With_name) => 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, +PropertyDefinition?: (node: PropertyDefinition) => void, +'PropertyDefinition[key]'?: (node: PropertyDefinition_With_key) => void, +'PropertyDefinition[value]'?: (node: PropertyDefinition_With_value) => void, +'PropertyDefinition[computed]'?: ( node: PropertyDefinition_With_computed, ) => void, +'PropertyDefinition[static]'?: ( node: PropertyDefinition_With_static, ) => void, +'PropertyDefinition[declare]'?: ( node: PropertyDefinition_With_declare, ) => void, +'PropertyDefinition[optional]'?: ( node: PropertyDefinition_With_optional, ) => void, +'PropertyDefinition[variance]'?: ( node: PropertyDefinition_With_variance, ) => void, +'PropertyDefinition[typeAnnotation]'?: ( node: PropertyDefinition_With_typeAnnotation, ) => void, +'PropertyDefinition[tsModifiers]'?: ( node: PropertyDefinition_With_tsModifiers, ) => void, +QualifiedTypeIdentifier?: (node: QualifiedTypeIdentifier) => void, +'QualifiedTypeIdentifier[qualification]'?: ( node: QualifiedTypeIdentifier_With_qualification, ) => void, +'QualifiedTypeIdentifier[id]'?: ( node: QualifiedTypeIdentifier_With_id, ) => void, +QualifiedTypeofIdentifier?: (node: QualifiedTypeofIdentifier) => void, +'QualifiedTypeofIdentifier[qualification]'?: ( node: QualifiedTypeofIdentifier_With_qualification, ) => void, +'QualifiedTypeofIdentifier[id]'?: ( node: QualifiedTypeofIdentifier_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, +'StringLiteralTypeAnnotation[raw]'?: ( node: StringLiteralTypeAnnotation_With_raw, ) => 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, +'TupleTypeAnnotation[inexact]'?: ( node: TupleTypeAnnotation_With_inexact, ) => void, +TupleTypeLabeledElement?: (node: TupleTypeLabeledElement) => void, +'TupleTypeLabeledElement[label]'?: ( node: TupleTypeLabeledElement_With_label, ) => void, +'TupleTypeLabeledElement[elementType]'?: ( node: TupleTypeLabeledElement_With_elementType, ) => void, +'TupleTypeLabeledElement[optional]'?: ( node: TupleTypeLabeledElement_With_optional, ) => void, +'TupleTypeLabeledElement[variance]'?: ( node: TupleTypeLabeledElement_With_variance, ) => void, +TupleTypeSpreadElement?: (node: TupleTypeSpreadElement) => void, +'TupleTypeSpreadElement[label]'?: ( node: TupleTypeSpreadElement_With_label, ) => void, +'TupleTypeSpreadElement[typeAnnotation]'?: ( node: TupleTypeSpreadElement_With_typeAnnotation, ) => 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, +'TypeofTypeAnnotation[typeArguments]'?: ( node: TypeofTypeAnnotation_With_typeArguments, ) => void, +TypeOperator?: (node: TypeOperator) => void, +'TypeOperator[operator]'?: (node: TypeOperator_With_operator) => void, +'TypeOperator[typeAnnotation]'?: ( node: TypeOperator_With_typeAnnotation, ) => 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, +'TypeParameter[usesExtendsBound]'?: ( node: TypeParameter_With_usesExtendsBound, ) => void, +TypeParameterDeclaration?: (node: TypeParameterDeclaration) => void, +'TypeParameterDeclaration[params]'?: ( node: TypeParameterDeclaration_With_params, ) => void, +TypeParameterInstantiation?: (node: TypeParameterInstantiation) => void, +'TypeParameterInstantiation[params]'?: ( node: TypeParameterInstantiation_With_params, ) => void, +TypePredicate?: (node: TypePredicate) => void, +'TypePredicate[parameterName]'?: ( node: TypePredicate_With_parameterName, ) => void, +'TypePredicate[typeAnnotation]'?: ( node: TypePredicate_With_typeAnnotation, ) => void, +'TypePredicate[kind]'?: (node: TypePredicate_With_kind) => 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, +'AsConstExpression:exit'?: (node: AsConstExpression) => void, +'AsConstExpression[expression]:exit'?: ( node: AsConstExpression_With_expression, ) => void, +'AsExpression:exit'?: (node: AsExpression) => void, +'AsExpression[expression]:exit'?: ( node: AsExpression_With_expression, ) => void, +'AsExpression[typeAnnotation]:exit'?: ( node: AsExpression_With_typeAnnotation, ) => 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, +'BigIntLiteralTypeAnnotation:exit'?: ( node: BigIntLiteralTypeAnnotation, ) => void, +'BigIntLiteralTypeAnnotation[raw]:exit'?: ( node: BigIntLiteralTypeAnnotation_With_raw, ) => void, +'BigIntTypeAnnotation:exit'?: (node: BigIntTypeAnnotation) => 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, +'ChainExpression:exit'?: (node: ChainExpression) => void, +'ChainExpression[expression]:exit'?: ( node: ChainExpression_With_expression, ) => 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, +'ComponentDeclaration:exit'?: (node: ComponentDeclaration) => void, +'ComponentDeclaration[id]:exit'?: ( node: ComponentDeclaration_With_id, ) => void, +'ComponentDeclaration[params]:exit'?: ( node: ComponentDeclaration_With_params, ) => void, +'ComponentDeclaration[body]:exit'?: ( node: ComponentDeclaration_With_body, ) => void, +'ComponentDeclaration[typeParameters]:exit'?: ( node: ComponentDeclaration_With_typeParameters, ) => void, +'ComponentDeclaration[rendersType]:exit'?: ( node: ComponentDeclaration_With_rendersType, ) => void, +'ComponentParameter:exit'?: (node: ComponentParameter) => void, +'ComponentParameter[name]:exit'?: ( node: ComponentParameter_With_name, ) => void, +'ComponentParameter[local]:exit'?: ( node: ComponentParameter_With_local, ) => void, +'ComponentParameter[shorthand]:exit'?: ( node: ComponentParameter_With_shorthand, ) => void, +'ComponentTypeAnnotation:exit'?: (node: ComponentTypeAnnotation) => void, +'ComponentTypeAnnotation[params]:exit'?: ( node: ComponentTypeAnnotation_With_params, ) => void, +'ComponentTypeAnnotation[rest]:exit'?: ( node: ComponentTypeAnnotation_With_rest, ) => void, +'ComponentTypeAnnotation[typeParameters]:exit'?: ( node: ComponentTypeAnnotation_With_typeParameters, ) => void, +'ComponentTypeAnnotation[rendersType]:exit'?: ( node: ComponentTypeAnnotation_With_rendersType, ) => void, +'ComponentTypeParameter:exit'?: (node: ComponentTypeParameter) => void, +'ComponentTypeParameter[name]:exit'?: ( node: ComponentTypeParameter_With_name, ) => void, +'ComponentTypeParameter[typeAnnotation]:exit'?: ( node: ComponentTypeParameter_With_typeAnnotation, ) => void, +'ComponentTypeParameter[optional]:exit'?: ( node: ComponentTypeParameter_With_optional, ) => 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, +'ConditionalTypeAnnotation:exit'?: (node: ConditionalTypeAnnotation) => void, +'ConditionalTypeAnnotation[checkType]:exit'?: ( node: ConditionalTypeAnnotation_With_checkType, ) => void, +'ConditionalTypeAnnotation[extendsType]:exit'?: ( node: ConditionalTypeAnnotation_With_extendsType, ) => void, +'ConditionalTypeAnnotation[trueType]:exit'?: ( node: ConditionalTypeAnnotation_With_trueType, ) => void, +'ConditionalTypeAnnotation[falseType]:exit'?: ( node: ConditionalTypeAnnotation_With_falseType, ) => 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, +'DeclareComponent:exit'?: (node: DeclareComponent) => void, +'DeclareComponent[id]:exit'?: (node: DeclareComponent_With_id) => void, +'DeclareComponent[params]:exit'?: ( node: DeclareComponent_With_params, ) => void, +'DeclareComponent[rest]:exit'?: (node: DeclareComponent_With_rest) => void, +'DeclareComponent[typeParameters]:exit'?: ( node: DeclareComponent_With_typeParameters, ) => void, +'DeclareComponent[rendersType]:exit'?: ( node: DeclareComponent_With_rendersType, ) => void, +'DeclaredPredicate:exit'?: (node: DeclaredPredicate) => void, +'DeclaredPredicate[value]:exit'?: ( node: DeclaredPredicate_With_value, ) => void, +'DeclareEnum:exit'?: (node: DeclareEnum) => void, +'DeclareEnum[id]:exit'?: (node: DeclareEnum_With_id) => void, +'DeclareEnum[body]:exit'?: (node: DeclareEnum_With_body) => 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, +'DeclareHook:exit'?: (node: DeclareHook) => void, +'DeclareHook[id]:exit'?: (node: DeclareHook_With_id) => 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, +'DeclareModuleExports:exit'?: (node: DeclareModuleExports) => void, +'DeclareModuleExports[typeAnnotation]:exit'?: ( node: DeclareModuleExports_With_typeAnnotation, ) => void, +'DeclareNamespace:exit'?: (node: DeclareNamespace) => void, +'DeclareNamespace[id]:exit'?: (node: DeclareNamespace_With_id) => void, +'DeclareNamespace[body]:exit'?: (node: DeclareNamespace_With_body) => 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, +'DeclareVariable[kind]:exit'?: (node: DeclareVariable_With_kind) => 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, +'EnumBigIntBody:exit'?: (node: EnumBigIntBody) => void, +'EnumBigIntBody[members]:exit'?: (node: EnumBigIntBody_With_members) => void, +'EnumBigIntBody[explicitType]:exit'?: ( node: EnumBigIntBody_With_explicitType, ) => void, +'EnumBigIntBody[hasUnknownMembers]:exit'?: ( node: EnumBigIntBody_With_hasUnknownMembers, ) => void, +'EnumBigIntMember:exit'?: (node: EnumBigIntMember) => void, +'EnumBigIntMember[id]:exit'?: (node: EnumBigIntMember_With_id) => void, +'EnumBigIntMember[init]:exit'?: (node: EnumBigIntMember_With_init) => 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[exported]:exit'?: ( node: ExportAllDeclaration_With_exported, ) => 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, +'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, +'HookDeclaration:exit'?: (node: HookDeclaration) => void, +'HookDeclaration[id]:exit'?: (node: HookDeclaration_With_id) => void, +'HookDeclaration[params]:exit'?: (node: HookDeclaration_With_params) => void, +'HookDeclaration[body]:exit'?: (node: HookDeclaration_With_body) => void, +'HookDeclaration[typeParameters]:exit'?: ( node: HookDeclaration_With_typeParameters, ) => void, +'HookDeclaration[returnType]:exit'?: ( node: HookDeclaration_With_returnType, ) => void, +'HookTypeAnnotation:exit'?: (node: HookTypeAnnotation) => void, +'HookTypeAnnotation[params]:exit'?: ( node: HookTypeAnnotation_With_params, ) => void, +'HookTypeAnnotation[returnType]:exit'?: ( node: HookTypeAnnotation_With_returnType, ) => void, +'HookTypeAnnotation[rest]:exit'?: ( node: HookTypeAnnotation_With_rest, ) => void, +'HookTypeAnnotation[typeParameters]:exit'?: ( node: HookTypeAnnotation_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, +'InferTypeAnnotation:exit'?: (node: InferTypeAnnotation) => void, +'InferTypeAnnotation[typeParameter]:exit'?: ( node: InferTypeAnnotation_With_typeParameter, ) => 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, +'JSXOpeningElement[typeArguments]:exit'?: ( node: JSXOpeningElement_With_typeArguments, ) => 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, +'KeyofTypeAnnotation:exit'?: (node: KeyofTypeAnnotation) => void, +'KeyofTypeAnnotation[argument]:exit'?: ( node: KeyofTypeAnnotation_With_argument, ) => 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, +'ObjectTypeMappedTypeProperty:exit'?: ( node: ObjectTypeMappedTypeProperty, ) => void, +'ObjectTypeMappedTypeProperty[keyTparam]:exit'?: ( node: ObjectTypeMappedTypeProperty_With_keyTparam, ) => void, +'ObjectTypeMappedTypeProperty[propType]:exit'?: ( node: ObjectTypeMappedTypeProperty_With_propType, ) => void, +'ObjectTypeMappedTypeProperty[sourceType]:exit'?: ( node: ObjectTypeMappedTypeProperty_With_sourceType, ) => void, +'ObjectTypeMappedTypeProperty[variance]:exit'?: ( node: ObjectTypeMappedTypeProperty_With_variance, ) => void, +'ObjectTypeMappedTypeProperty[optional]:exit'?: ( node: ObjectTypeMappedTypeProperty_With_optional, ) => 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, +'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, +'PrivateIdentifier:exit'?: (node: PrivateIdentifier) => void, +'PrivateIdentifier[name]:exit'?: (node: PrivateIdentifier_With_name) => 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, +'PropertyDefinition:exit'?: (node: PropertyDefinition) => void, +'PropertyDefinition[key]:exit'?: (node: PropertyDefinition_With_key) => void, +'PropertyDefinition[value]:exit'?: ( node: PropertyDefinition_With_value, ) => void, +'PropertyDefinition[computed]:exit'?: ( node: PropertyDefinition_With_computed, ) => void, +'PropertyDefinition[static]:exit'?: ( node: PropertyDefinition_With_static, ) => void, +'PropertyDefinition[declare]:exit'?: ( node: PropertyDefinition_With_declare, ) => void, +'PropertyDefinition[optional]:exit'?: ( node: PropertyDefinition_With_optional, ) => void, +'PropertyDefinition[variance]:exit'?: ( node: PropertyDefinition_With_variance, ) => void, +'PropertyDefinition[typeAnnotation]:exit'?: ( node: PropertyDefinition_With_typeAnnotation, ) => void, +'PropertyDefinition[tsModifiers]:exit'?: ( node: PropertyDefinition_With_tsModifiers, ) => void, +'QualifiedTypeIdentifier:exit'?: (node: QualifiedTypeIdentifier) => void, +'QualifiedTypeIdentifier[qualification]:exit'?: ( node: QualifiedTypeIdentifier_With_qualification, ) => void, +'QualifiedTypeIdentifier[id]:exit'?: ( node: QualifiedTypeIdentifier_With_id, ) => void, +'QualifiedTypeofIdentifier:exit'?: (node: QualifiedTypeofIdentifier) => void, +'QualifiedTypeofIdentifier[qualification]:exit'?: ( node: QualifiedTypeofIdentifier_With_qualification, ) => void, +'QualifiedTypeofIdentifier[id]:exit'?: ( node: QualifiedTypeofIdentifier_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, +'StringLiteralTypeAnnotation[raw]:exit'?: ( node: StringLiteralTypeAnnotation_With_raw, ) => 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, +'TupleTypeAnnotation[inexact]:exit'?: ( node: TupleTypeAnnotation_With_inexact, ) => void, +'TupleTypeLabeledElement:exit'?: (node: TupleTypeLabeledElement) => void, +'TupleTypeLabeledElement[label]:exit'?: ( node: TupleTypeLabeledElement_With_label, ) => void, +'TupleTypeLabeledElement[elementType]:exit'?: ( node: TupleTypeLabeledElement_With_elementType, ) => void, +'TupleTypeLabeledElement[optional]:exit'?: ( node: TupleTypeLabeledElement_With_optional, ) => void, +'TupleTypeLabeledElement[variance]:exit'?: ( node: TupleTypeLabeledElement_With_variance, ) => void, +'TupleTypeSpreadElement:exit'?: (node: TupleTypeSpreadElement) => void, +'TupleTypeSpreadElement[label]:exit'?: ( node: TupleTypeSpreadElement_With_label, ) => void, +'TupleTypeSpreadElement[typeAnnotation]:exit'?: ( node: TupleTypeSpreadElement_With_typeAnnotation, ) => 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, +'TypeofTypeAnnotation[typeArguments]:exit'?: ( node: TypeofTypeAnnotation_With_typeArguments, ) => void, +'TypeOperator:exit'?: (node: TypeOperator) => void, +'TypeOperator[operator]:exit'?: (node: TypeOperator_With_operator) => void, +'TypeOperator[typeAnnotation]:exit'?: ( node: TypeOperator_With_typeAnnotation, ) => 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, +'TypeParameter[usesExtendsBound]:exit'?: ( node: TypeParameter_With_usesExtendsBound, ) => 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, +'TypePredicate:exit'?: (node: TypePredicate) => void, +'TypePredicate[parameterName]:exit'?: ( node: TypePredicate_With_parameterName, ) => void, +'TypePredicate[typeAnnotation]:exit'?: ( node: TypePredicate_With_typeAnnotation, ) => void, +'TypePredicate[kind]:exit'?: (node: TypePredicate_With_kind) => 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, };