ast-types

  • Version 0.14.2
  • Published
  • 484 kB
  • 1 dependency
  • MIT license

Install

npm i ast-types
yarn add ast-types
pnpm add ast-types

Overview

Esprima-compatible implementation of the Mozilla JS Parser API

Index

Variables

Functions

Interfaces

Type Aliases

Namespaces

Variables

variable astNodesAreEquivalent

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

    variable builders

    const builders: builders;

      variable builtInTypes

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

        variable NodePath

        const NodePath: NodePathConstructor;

          variable Path

          const Path: PathConstructor;

            variable PathVisitor

            const PathVisitor: PathVisitorConstructor;

              variable Type

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

                Functions

                function defineMethod

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

                  function eachField

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

                    function finalize

                    finalize: () => void;

                      function getBuilderName

                      getBuilderName: (typeName: any) => any;

                        function getFieldNames

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

                          function getFieldValue

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

                            function getSupertypeNames

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

                              function someField

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

                                function use

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

                                  function visit

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

                                    Interfaces

                                    interface AnyType

                                    interface AnyType {}

                                      method arrayOf

                                      arrayOf: () => AnyType;

                                        method assert

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

                                          method check

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

                                            method toString

                                            toString: () => string;

                                              interface ASTNode

                                              interface ASTNode {}

                                                property type

                                                type: string;

                                                  interface builders

                                                  interface builders {}

                                                    property anyTypeAnnotation

                                                    anyTypeAnnotation: AnyTypeAnnotationBuilder;

                                                      property arrayExpression

                                                      arrayExpression: ArrayExpressionBuilder;

                                                        property arrayPattern

                                                        arrayPattern: ArrayPatternBuilder;

                                                          property arrayTypeAnnotation

                                                          arrayTypeAnnotation: ArrayTypeAnnotationBuilder;

                                                            property arrowFunctionExpression

                                                            arrowFunctionExpression: ArrowFunctionExpressionBuilder;

                                                              property assignmentExpression

                                                              assignmentExpression: AssignmentExpressionBuilder;

                                                                property assignmentPattern

                                                                assignmentPattern: AssignmentPatternBuilder;

                                                                  property awaitExpression

                                                                  awaitExpression: AwaitExpressionBuilder;

                                                                    property bigIntLiteral

                                                                    bigIntLiteral: BigIntLiteralBuilder;

                                                                      property bigIntLiteralTypeAnnotation

                                                                      bigIntLiteralTypeAnnotation: BigIntLiteralTypeAnnotationBuilder;

                                                                        property bigIntTypeAnnotation

                                                                        bigIntTypeAnnotation: BigIntTypeAnnotationBuilder;

                                                                          property binaryExpression

                                                                          binaryExpression: BinaryExpressionBuilder;

                                                                            property bindExpression

                                                                            bindExpression: BindExpressionBuilder;

                                                                              property block

                                                                              block: BlockBuilder;

                                                                                property blockStatement

                                                                                blockStatement: BlockStatementBuilder;

                                                                                  property booleanLiteral

                                                                                  booleanLiteral: BooleanLiteralBuilder;

                                                                                    property booleanLiteralTypeAnnotation

                                                                                    booleanLiteralTypeAnnotation: BooleanLiteralTypeAnnotationBuilder;

                                                                                      property booleanTypeAnnotation

                                                                                      booleanTypeAnnotation: BooleanTypeAnnotationBuilder;

                                                                                        property breakStatement

                                                                                        breakStatement: BreakStatementBuilder;

                                                                                          property callExpression

                                                                                          callExpression: CallExpressionBuilder;

                                                                                            property catchClause

                                                                                            catchClause: CatchClauseBuilder;

                                                                                              property chainExpression

                                                                                              chainExpression: ChainExpressionBuilder;

                                                                                                property classBody

                                                                                                classBody: ClassBodyBuilder;

                                                                                                  property classDeclaration

                                                                                                  classDeclaration: ClassDeclarationBuilder;

                                                                                                    property classExpression

                                                                                                    classExpression: ClassExpressionBuilder;

                                                                                                      property classImplements

                                                                                                      classImplements: ClassImplementsBuilder;

                                                                                                        property classMethod

                                                                                                        classMethod: ClassMethodBuilder;

                                                                                                          property classPrivateMethod

                                                                                                          classPrivateMethod: ClassPrivateMethodBuilder;

                                                                                                            property classPrivateProperty

                                                                                                            classPrivateProperty: ClassPrivatePropertyBuilder;

                                                                                                              property classProperty

                                                                                                              classProperty: ClassPropertyBuilder;

                                                                                                                property classPropertyDefinition

                                                                                                                classPropertyDefinition: ClassPropertyDefinitionBuilder;

                                                                                                                  property commentBlock

                                                                                                                  commentBlock: CommentBlockBuilder;

                                                                                                                    property commentLine

                                                                                                                    commentLine: CommentLineBuilder;

                                                                                                                      property comprehensionBlock

                                                                                                                      comprehensionBlock: ComprehensionBlockBuilder;

                                                                                                                        property comprehensionExpression

                                                                                                                        comprehensionExpression: ComprehensionExpressionBuilder;

                                                                                                                          property conditionalExpression

                                                                                                                          conditionalExpression: ConditionalExpressionBuilder;

                                                                                                                            property continueStatement

                                                                                                                            continueStatement: ContinueStatementBuilder;

                                                                                                                              property debuggerStatement

                                                                                                                              debuggerStatement: DebuggerStatementBuilder;

                                                                                                                                property declareClass

                                                                                                                                declareClass: DeclareClassBuilder;

                                                                                                                                  property declaredPredicate

                                                                                                                                  declaredPredicate: DeclaredPredicateBuilder;

                                                                                                                                    property declareExportAllDeclaration

                                                                                                                                    declareExportAllDeclaration: DeclareExportAllDeclarationBuilder;

                                                                                                                                      property declareExportDeclaration

                                                                                                                                      declareExportDeclaration: DeclareExportDeclarationBuilder;

                                                                                                                                        property declareFunction

                                                                                                                                        declareFunction: DeclareFunctionBuilder;

                                                                                                                                          property declareInterface

                                                                                                                                          declareInterface: DeclareInterfaceBuilder;

                                                                                                                                            property declareModule

                                                                                                                                            declareModule: DeclareModuleBuilder;

                                                                                                                                              property declareModuleExports

                                                                                                                                              declareModuleExports: DeclareModuleExportsBuilder;

                                                                                                                                                property declareOpaqueType

                                                                                                                                                declareOpaqueType: DeclareOpaqueTypeBuilder;

                                                                                                                                                  property declareTypeAlias

                                                                                                                                                  declareTypeAlias: DeclareTypeAliasBuilder;

                                                                                                                                                    property declareVariable

                                                                                                                                                    declareVariable: DeclareVariableBuilder;

                                                                                                                                                      property decorator

                                                                                                                                                      decorator: DecoratorBuilder;

                                                                                                                                                        property directive

                                                                                                                                                        directive: DirectiveBuilder;

                                                                                                                                                          property directiveLiteral

                                                                                                                                                          directiveLiteral: DirectiveLiteralBuilder;

                                                                                                                                                            property doExpression

                                                                                                                                                            doExpression: DoExpressionBuilder;

                                                                                                                                                              property doWhileStatement

                                                                                                                                                              doWhileStatement: DoWhileStatementBuilder;

                                                                                                                                                                property emptyStatement

                                                                                                                                                                emptyStatement: EmptyStatementBuilder;

                                                                                                                                                                  property emptyTypeAnnotation

                                                                                                                                                                  emptyTypeAnnotation: EmptyTypeAnnotationBuilder;

                                                                                                                                                                    property enumBooleanBody

                                                                                                                                                                    enumBooleanBody: EnumBooleanBodyBuilder;

                                                                                                                                                                      property enumBooleanMember

                                                                                                                                                                      enumBooleanMember: EnumBooleanMemberBuilder;

                                                                                                                                                                        property enumDeclaration

                                                                                                                                                                        enumDeclaration: EnumDeclarationBuilder;

                                                                                                                                                                          property enumDefaultedMember

                                                                                                                                                                          enumDefaultedMember: EnumDefaultedMemberBuilder;

                                                                                                                                                                            property enumNumberBody

                                                                                                                                                                            enumNumberBody: EnumNumberBodyBuilder;

                                                                                                                                                                              property enumNumberMember

                                                                                                                                                                              enumNumberMember: EnumNumberMemberBuilder;

                                                                                                                                                                                property enumStringBody

                                                                                                                                                                                enumStringBody: EnumStringBodyBuilder;

                                                                                                                                                                                  property enumStringMember

                                                                                                                                                                                  enumStringMember: EnumStringMemberBuilder;

                                                                                                                                                                                    property enumSymbolBody

                                                                                                                                                                                    enumSymbolBody: EnumSymbolBodyBuilder;

                                                                                                                                                                                      property existentialTypeParam

                                                                                                                                                                                      existentialTypeParam: ExistentialTypeParamBuilder;

                                                                                                                                                                                        property existsTypeAnnotation

                                                                                                                                                                                        existsTypeAnnotation: ExistsTypeAnnotationBuilder;

                                                                                                                                                                                          property exportAllDeclaration

                                                                                                                                                                                          exportAllDeclaration: ExportAllDeclarationBuilder;

                                                                                                                                                                                            property exportBatchSpecifier

                                                                                                                                                                                            exportBatchSpecifier: ExportBatchSpecifierBuilder;

                                                                                                                                                                                              property exportDeclaration

                                                                                                                                                                                              exportDeclaration: ExportDeclarationBuilder;

                                                                                                                                                                                                property exportDefaultDeclaration

                                                                                                                                                                                                exportDefaultDeclaration: ExportDefaultDeclarationBuilder;

                                                                                                                                                                                                  property exportDefaultSpecifier

                                                                                                                                                                                                  exportDefaultSpecifier: ExportDefaultSpecifierBuilder;

                                                                                                                                                                                                    property exportNamedDeclaration

                                                                                                                                                                                                    exportNamedDeclaration: ExportNamedDeclarationBuilder;

                                                                                                                                                                                                      property exportNamespaceSpecifier

                                                                                                                                                                                                      exportNamespaceSpecifier: ExportNamespaceSpecifierBuilder;

                                                                                                                                                                                                        property exportSpecifier

                                                                                                                                                                                                        exportSpecifier: ExportSpecifierBuilder;

                                                                                                                                                                                                          property expressionStatement

                                                                                                                                                                                                          expressionStatement: ExpressionStatementBuilder;

                                                                                                                                                                                                            property file

                                                                                                                                                                                                            file: FileBuilder;

                                                                                                                                                                                                              property forAwaitStatement

                                                                                                                                                                                                              forAwaitStatement: ForAwaitStatementBuilder;

                                                                                                                                                                                                                property forInStatement

                                                                                                                                                                                                                forInStatement: ForInStatementBuilder;

                                                                                                                                                                                                                  property forOfStatement

                                                                                                                                                                                                                  forOfStatement: ForOfStatementBuilder;

                                                                                                                                                                                                                    property forStatement

                                                                                                                                                                                                                    forStatement: ForStatementBuilder;

                                                                                                                                                                                                                      property functionDeclaration

                                                                                                                                                                                                                      functionDeclaration: FunctionDeclarationBuilder;

                                                                                                                                                                                                                        property functionExpression

                                                                                                                                                                                                                        functionExpression: FunctionExpressionBuilder;

                                                                                                                                                                                                                          property functionTypeAnnotation

                                                                                                                                                                                                                          functionTypeAnnotation: FunctionTypeAnnotationBuilder;

                                                                                                                                                                                                                            property functionTypeParam

                                                                                                                                                                                                                            functionTypeParam: FunctionTypeParamBuilder;

                                                                                                                                                                                                                              property generatorExpression

                                                                                                                                                                                                                              generatorExpression: GeneratorExpressionBuilder;

                                                                                                                                                                                                                                property genericTypeAnnotation

                                                                                                                                                                                                                                genericTypeAnnotation: GenericTypeAnnotationBuilder;

                                                                                                                                                                                                                                  property identifier

                                                                                                                                                                                                                                  identifier: IdentifierBuilder;

                                                                                                                                                                                                                                    property ifStatement

                                                                                                                                                                                                                                    ifStatement: IfStatementBuilder;

                                                                                                                                                                                                                                      property import

                                                                                                                                                                                                                                      import: ImportBuilder;

                                                                                                                                                                                                                                        property importDeclaration

                                                                                                                                                                                                                                        importDeclaration: ImportDeclarationBuilder;

                                                                                                                                                                                                                                          property importDefaultSpecifier

                                                                                                                                                                                                                                          importDefaultSpecifier: ImportDefaultSpecifierBuilder;

                                                                                                                                                                                                                                            property importExpression

                                                                                                                                                                                                                                            importExpression: ImportExpressionBuilder;

                                                                                                                                                                                                                                              property importNamespaceSpecifier

                                                                                                                                                                                                                                              importNamespaceSpecifier: ImportNamespaceSpecifierBuilder;

                                                                                                                                                                                                                                                property importSpecifier

                                                                                                                                                                                                                                                importSpecifier: ImportSpecifierBuilder;

                                                                                                                                                                                                                                                  property inferredPredicate

                                                                                                                                                                                                                                                  inferredPredicate: InferredPredicateBuilder;

                                                                                                                                                                                                                                                    property interfaceDeclaration

                                                                                                                                                                                                                                                    interfaceDeclaration: InterfaceDeclarationBuilder;

                                                                                                                                                                                                                                                      property interfaceExtends

                                                                                                                                                                                                                                                      interfaceExtends: InterfaceExtendsBuilder;

                                                                                                                                                                                                                                                        property interfaceTypeAnnotation

                                                                                                                                                                                                                                                        interfaceTypeAnnotation: InterfaceTypeAnnotationBuilder;

                                                                                                                                                                                                                                                          property interpreterDirective

                                                                                                                                                                                                                                                          interpreterDirective: InterpreterDirectiveBuilder;

                                                                                                                                                                                                                                                            property intersectionTypeAnnotation

                                                                                                                                                                                                                                                            intersectionTypeAnnotation: IntersectionTypeAnnotationBuilder;

                                                                                                                                                                                                                                                              property jsxAttribute

                                                                                                                                                                                                                                                              jsxAttribute: JSXAttributeBuilder;

                                                                                                                                                                                                                                                                property jsxClosingElement

                                                                                                                                                                                                                                                                jsxClosingElement: JSXClosingElementBuilder;

                                                                                                                                                                                                                                                                  property jsxClosingFragment

                                                                                                                                                                                                                                                                  jsxClosingFragment: JSXClosingFragmentBuilder;

                                                                                                                                                                                                                                                                    property jsxElement

                                                                                                                                                                                                                                                                    jsxElement: JSXElementBuilder;

                                                                                                                                                                                                                                                                      property jsxEmptyExpression

                                                                                                                                                                                                                                                                      jsxEmptyExpression: JSXEmptyExpressionBuilder;

                                                                                                                                                                                                                                                                        property jsxExpressionContainer

                                                                                                                                                                                                                                                                        jsxExpressionContainer: JSXExpressionContainerBuilder;

                                                                                                                                                                                                                                                                          property jsxFragment

                                                                                                                                                                                                                                                                          jsxFragment: JSXFragmentBuilder;

                                                                                                                                                                                                                                                                            property jsxIdentifier

                                                                                                                                                                                                                                                                            jsxIdentifier: JSXIdentifierBuilder;

                                                                                                                                                                                                                                                                              property jsxMemberExpression

                                                                                                                                                                                                                                                                              jsxMemberExpression: JSXMemberExpressionBuilder;

                                                                                                                                                                                                                                                                                property jsxNamespacedName

                                                                                                                                                                                                                                                                                jsxNamespacedName: JSXNamespacedNameBuilder;

                                                                                                                                                                                                                                                                                  property jsxOpeningElement

                                                                                                                                                                                                                                                                                  jsxOpeningElement: JSXOpeningElementBuilder;

                                                                                                                                                                                                                                                                                    property jsxOpeningFragment

                                                                                                                                                                                                                                                                                    jsxOpeningFragment: JSXOpeningFragmentBuilder;

                                                                                                                                                                                                                                                                                      property jsxSpreadAttribute

                                                                                                                                                                                                                                                                                      jsxSpreadAttribute: JSXSpreadAttributeBuilder;

                                                                                                                                                                                                                                                                                        property jsxSpreadChild

                                                                                                                                                                                                                                                                                        jsxSpreadChild: JSXSpreadChildBuilder;

                                                                                                                                                                                                                                                                                          property jsxText

                                                                                                                                                                                                                                                                                          jsxText: JSXTextBuilder;

                                                                                                                                                                                                                                                                                            property labeledStatement

                                                                                                                                                                                                                                                                                            labeledStatement: LabeledStatementBuilder;

                                                                                                                                                                                                                                                                                              property line

                                                                                                                                                                                                                                                                                              line: LineBuilder;

                                                                                                                                                                                                                                                                                                property literal

                                                                                                                                                                                                                                                                                                literal: LiteralBuilder;

                                                                                                                                                                                                                                                                                                  property logicalExpression

                                                                                                                                                                                                                                                                                                  logicalExpression: LogicalExpressionBuilder;

                                                                                                                                                                                                                                                                                                    property memberExpression

                                                                                                                                                                                                                                                                                                    memberExpression: MemberExpressionBuilder;

                                                                                                                                                                                                                                                                                                      property memberTypeAnnotation

                                                                                                                                                                                                                                                                                                      memberTypeAnnotation: MemberTypeAnnotationBuilder;

                                                                                                                                                                                                                                                                                                        property metaProperty

                                                                                                                                                                                                                                                                                                        metaProperty: MetaPropertyBuilder;

                                                                                                                                                                                                                                                                                                          property methodDefinition

                                                                                                                                                                                                                                                                                                          methodDefinition: MethodDefinitionBuilder;

                                                                                                                                                                                                                                                                                                            property mixedTypeAnnotation

                                                                                                                                                                                                                                                                                                            mixedTypeAnnotation: MixedTypeAnnotationBuilder;

                                                                                                                                                                                                                                                                                                              property newExpression

                                                                                                                                                                                                                                                                                                              newExpression: NewExpressionBuilder;

                                                                                                                                                                                                                                                                                                                property noop

                                                                                                                                                                                                                                                                                                                noop: NoopBuilder;

                                                                                                                                                                                                                                                                                                                  property nullableTypeAnnotation

                                                                                                                                                                                                                                                                                                                  nullableTypeAnnotation: NullableTypeAnnotationBuilder;

                                                                                                                                                                                                                                                                                                                    property nullLiteral

                                                                                                                                                                                                                                                                                                                    nullLiteral: NullLiteralBuilder;

                                                                                                                                                                                                                                                                                                                      property nullLiteralTypeAnnotation

                                                                                                                                                                                                                                                                                                                      nullLiteralTypeAnnotation: NullLiteralTypeAnnotationBuilder;

                                                                                                                                                                                                                                                                                                                        property nullTypeAnnotation

                                                                                                                                                                                                                                                                                                                        nullTypeAnnotation: NullTypeAnnotationBuilder;

                                                                                                                                                                                                                                                                                                                          property numberLiteralTypeAnnotation

                                                                                                                                                                                                                                                                                                                          numberLiteralTypeAnnotation: NumberLiteralTypeAnnotationBuilder;

                                                                                                                                                                                                                                                                                                                            property numberTypeAnnotation

                                                                                                                                                                                                                                                                                                                            numberTypeAnnotation: NumberTypeAnnotationBuilder;

                                                                                                                                                                                                                                                                                                                              property numericLiteral

                                                                                                                                                                                                                                                                                                                              numericLiteral: NumericLiteralBuilder;

                                                                                                                                                                                                                                                                                                                                property numericLiteralTypeAnnotation

                                                                                                                                                                                                                                                                                                                                numericLiteralTypeAnnotation: NumericLiteralTypeAnnotationBuilder;

                                                                                                                                                                                                                                                                                                                                  property objectExpression

                                                                                                                                                                                                                                                                                                                                  objectExpression: ObjectExpressionBuilder;

                                                                                                                                                                                                                                                                                                                                    property objectMethod

                                                                                                                                                                                                                                                                                                                                    objectMethod: ObjectMethodBuilder;

                                                                                                                                                                                                                                                                                                                                      property objectPattern

                                                                                                                                                                                                                                                                                                                                      objectPattern: ObjectPatternBuilder;

                                                                                                                                                                                                                                                                                                                                        property objectProperty

                                                                                                                                                                                                                                                                                                                                        objectProperty: ObjectPropertyBuilder;

                                                                                                                                                                                                                                                                                                                                          property objectTypeAnnotation

                                                                                                                                                                                                                                                                                                                                          objectTypeAnnotation: ObjectTypeAnnotationBuilder;

                                                                                                                                                                                                                                                                                                                                            property objectTypeCallProperty

                                                                                                                                                                                                                                                                                                                                            objectTypeCallProperty: ObjectTypeCallPropertyBuilder;

                                                                                                                                                                                                                                                                                                                                              property objectTypeIndexer

                                                                                                                                                                                                                                                                                                                                              objectTypeIndexer: ObjectTypeIndexerBuilder;

                                                                                                                                                                                                                                                                                                                                                property objectTypeInternalSlot

                                                                                                                                                                                                                                                                                                                                                objectTypeInternalSlot: ObjectTypeInternalSlotBuilder;

                                                                                                                                                                                                                                                                                                                                                  property objectTypeProperty

                                                                                                                                                                                                                                                                                                                                                  objectTypeProperty: ObjectTypePropertyBuilder;

                                                                                                                                                                                                                                                                                                                                                    property objectTypeSpreadProperty

                                                                                                                                                                                                                                                                                                                                                    objectTypeSpreadProperty: ObjectTypeSpreadPropertyBuilder;

                                                                                                                                                                                                                                                                                                                                                      property opaqueType

                                                                                                                                                                                                                                                                                                                                                      opaqueType: OpaqueTypeBuilder;

                                                                                                                                                                                                                                                                                                                                                        property optionalCallExpression

                                                                                                                                                                                                                                                                                                                                                        optionalCallExpression: OptionalCallExpressionBuilder;

                                                                                                                                                                                                                                                                                                                                                          property optionalMemberExpression

                                                                                                                                                                                                                                                                                                                                                          optionalMemberExpression: OptionalMemberExpressionBuilder;

                                                                                                                                                                                                                                                                                                                                                            property parenthesizedExpression

                                                                                                                                                                                                                                                                                                                                                            parenthesizedExpression: ParenthesizedExpressionBuilder;

                                                                                                                                                                                                                                                                                                                                                              property privateName

                                                                                                                                                                                                                                                                                                                                                              privateName: PrivateNameBuilder;

                                                                                                                                                                                                                                                                                                                                                                property program

                                                                                                                                                                                                                                                                                                                                                                program: ProgramBuilder;

                                                                                                                                                                                                                                                                                                                                                                  property property

                                                                                                                                                                                                                                                                                                                                                                  property: PropertyBuilder;

                                                                                                                                                                                                                                                                                                                                                                    property propertyPattern

                                                                                                                                                                                                                                                                                                                                                                    propertyPattern: PropertyPatternBuilder;

                                                                                                                                                                                                                                                                                                                                                                      property qualifiedTypeIdentifier

                                                                                                                                                                                                                                                                                                                                                                      qualifiedTypeIdentifier: QualifiedTypeIdentifierBuilder;

                                                                                                                                                                                                                                                                                                                                                                        property regExpLiteral

                                                                                                                                                                                                                                                                                                                                                                        regExpLiteral: RegExpLiteralBuilder;

                                                                                                                                                                                                                                                                                                                                                                          property restElement

                                                                                                                                                                                                                                                                                                                                                                          restElement: RestElementBuilder;

                                                                                                                                                                                                                                                                                                                                                                            property restProperty

                                                                                                                                                                                                                                                                                                                                                                            restProperty: RestPropertyBuilder;

                                                                                                                                                                                                                                                                                                                                                                              property returnStatement

                                                                                                                                                                                                                                                                                                                                                                              returnStatement: ReturnStatementBuilder;

                                                                                                                                                                                                                                                                                                                                                                                property sequenceExpression

                                                                                                                                                                                                                                                                                                                                                                                sequenceExpression: SequenceExpressionBuilder;

                                                                                                                                                                                                                                                                                                                                                                                  property spreadElement

                                                                                                                                                                                                                                                                                                                                                                                  spreadElement: SpreadElementBuilder;

                                                                                                                                                                                                                                                                                                                                                                                    property spreadElementPattern

                                                                                                                                                                                                                                                                                                                                                                                    spreadElementPattern: SpreadElementPatternBuilder;

                                                                                                                                                                                                                                                                                                                                                                                      property spreadProperty

                                                                                                                                                                                                                                                                                                                                                                                      spreadProperty: SpreadPropertyBuilder;

                                                                                                                                                                                                                                                                                                                                                                                        property spreadPropertyPattern

                                                                                                                                                                                                                                                                                                                                                                                        spreadPropertyPattern: SpreadPropertyPatternBuilder;

                                                                                                                                                                                                                                                                                                                                                                                          property stringLiteral

                                                                                                                                                                                                                                                                                                                                                                                          stringLiteral: StringLiteralBuilder;

                                                                                                                                                                                                                                                                                                                                                                                            property stringLiteralTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                            stringLiteralTypeAnnotation: StringLiteralTypeAnnotationBuilder;

                                                                                                                                                                                                                                                                                                                                                                                              property stringTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                              stringTypeAnnotation: StringTypeAnnotationBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                property super

                                                                                                                                                                                                                                                                                                                                                                                                super: SuperBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                  property switchCase

                                                                                                                                                                                                                                                                                                                                                                                                  switchCase: SwitchCaseBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                    property switchStatement

                                                                                                                                                                                                                                                                                                                                                                                                    switchStatement: SwitchStatementBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                      property symbolTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                      symbolTypeAnnotation: SymbolTypeAnnotationBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                        property taggedTemplateExpression

                                                                                                                                                                                                                                                                                                                                                                                                        taggedTemplateExpression: TaggedTemplateExpressionBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                          property templateElement

                                                                                                                                                                                                                                                                                                                                                                                                          templateElement: TemplateElementBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                            property templateLiteral

                                                                                                                                                                                                                                                                                                                                                                                                            templateLiteral: TemplateLiteralBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                              property thisExpression

                                                                                                                                                                                                                                                                                                                                                                                                              thisExpression: ThisExpressionBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                property thisTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                thisTypeAnnotation: ThisTypeAnnotationBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                  property throwStatement

                                                                                                                                                                                                                                                                                                                                                                                                                  throwStatement: ThrowStatementBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                    property tryStatement

                                                                                                                                                                                                                                                                                                                                                                                                                    tryStatement: TryStatementBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                      property tsAnyKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                      tsAnyKeyword: TSAnyKeywordBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                        property tsArrayType

                                                                                                                                                                                                                                                                                                                                                                                                                        tsArrayType: TSArrayTypeBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                          property tsAsExpression

                                                                                                                                                                                                                                                                                                                                                                                                                          tsAsExpression: TSAsExpressionBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                            property tsBigIntKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                            tsBigIntKeyword: TSBigIntKeywordBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                              property tsBooleanKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                              tsBooleanKeyword: TSBooleanKeywordBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                property tsCallSignatureDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                tsCallSignatureDeclaration: TSCallSignatureDeclarationBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                  property tsConditionalType

                                                                                                                                                                                                                                                                                                                                                                                                                                  tsConditionalType: TSConditionalTypeBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                    property tsConstructorType

                                                                                                                                                                                                                                                                                                                                                                                                                                    tsConstructorType: TSConstructorTypeBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                      property tsConstructSignatureDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                      tsConstructSignatureDeclaration: TSConstructSignatureDeclarationBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                        property tsDeclareFunction

                                                                                                                                                                                                                                                                                                                                                                                                                                        tsDeclareFunction: TSDeclareFunctionBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                          property tsDeclareMethod

                                                                                                                                                                                                                                                                                                                                                                                                                                          tsDeclareMethod: TSDeclareMethodBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                            property tsEnumDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                            tsEnumDeclaration: TSEnumDeclarationBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                              property tsEnumMember

                                                                                                                                                                                                                                                                                                                                                                                                                                              tsEnumMember: TSEnumMemberBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                property tsExportAssignment

                                                                                                                                                                                                                                                                                                                                                                                                                                                tsExportAssignment: TSExportAssignmentBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  property tsExpressionWithTypeArguments

                                                                                                                                                                                                                                                                                                                                                                                                                                                  tsExpressionWithTypeArguments: TSExpressionWithTypeArgumentsBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    property tsExternalModuleReference

                                                                                                                                                                                                                                                                                                                                                                                                                                                    tsExternalModuleReference: TSExternalModuleReferenceBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      property tsFunctionType

                                                                                                                                                                                                                                                                                                                                                                                                                                                      tsFunctionType: TSFunctionTypeBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        property tsImportEqualsDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                        tsImportEqualsDeclaration: TSImportEqualsDeclarationBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          property tsImportType

                                                                                                                                                                                                                                                                                                                                                                                                                                                          tsImportType: TSImportTypeBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            property tsIndexedAccessType

                                                                                                                                                                                                                                                                                                                                                                                                                                                            tsIndexedAccessType: TSIndexedAccessTypeBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              property tsIndexSignature

                                                                                                                                                                                                                                                                                                                                                                                                                                                              tsIndexSignature: TSIndexSignatureBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                property tsInferType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                tsInferType: TSInferTypeBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property tsInterfaceBody

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  tsInterfaceBody: TSInterfaceBodyBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property tsInterfaceDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    tsInterfaceDeclaration: TSInterfaceDeclarationBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property tsIntersectionType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      tsIntersectionType: TSIntersectionTypeBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property tsLiteralType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        tsLiteralType: TSLiteralTypeBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property tsMappedType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          tsMappedType: TSMappedTypeBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property tsMethodSignature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            tsMethodSignature: TSMethodSignatureBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property tsModuleBlock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              tsModuleBlock: TSModuleBlockBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property tsModuleDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                tsModuleDeclaration: TSModuleDeclarationBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property tsNamedTupleMember

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  tsNamedTupleMember: TSNamedTupleMemberBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property tsNamespaceExportDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    tsNamespaceExportDeclaration: TSNamespaceExportDeclarationBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property tsNeverKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      tsNeverKeyword: TSNeverKeywordBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property tsNonNullExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        tsNonNullExpression: TSNonNullExpressionBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property tsNullKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          tsNullKeyword: TSNullKeywordBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property tsNumberKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            tsNumberKeyword: TSNumberKeywordBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property tsObjectKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              tsObjectKeyword: TSObjectKeywordBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property tsOptionalType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                tsOptionalType: TSOptionalTypeBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property tsParameterProperty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  tsParameterProperty: TSParameterPropertyBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property tsParenthesizedType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    tsParenthesizedType: TSParenthesizedTypeBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property tsPropertySignature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      tsPropertySignature: TSPropertySignatureBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property tsQualifiedName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        tsQualifiedName: TSQualifiedNameBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property tsRestType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          tsRestType: TSRestTypeBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property tsStringKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            tsStringKeyword: TSStringKeywordBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property tsSymbolKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              tsSymbolKeyword: TSSymbolKeywordBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property tsThisType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                tsThisType: TSThisTypeBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property tsTupleType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  tsTupleType: TSTupleTypeBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property tsTypeAliasDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    tsTypeAliasDeclaration: TSTypeAliasDeclarationBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property tsTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      tsTypeAnnotation: TSTypeAnnotationBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property tsTypeAssertion

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        tsTypeAssertion: TSTypeAssertionBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property tsTypeLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          tsTypeLiteral: TSTypeLiteralBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property tsTypeOperator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            tsTypeOperator: TSTypeOperatorBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property tsTypeParameter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              tsTypeParameter: TSTypeParameterBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property tsTypeParameterDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                tsTypeParameterDeclaration: TSTypeParameterDeclarationBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property tsTypeParameterInstantiation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  tsTypeParameterInstantiation: TSTypeParameterInstantiationBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property tsTypePredicate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    tsTypePredicate: TSTypePredicateBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property tsTypeQuery

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      tsTypeQuery: TSTypeQueryBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property tsTypeReference

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        tsTypeReference: TSTypeReferenceBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property tsUndefinedKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          tsUndefinedKeyword: TSUndefinedKeywordBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property tsUnionType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            tsUnionType: TSUnionTypeBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property tsUnknownKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              tsUnknownKeyword: TSUnknownKeywordBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property tsVoidKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                tsVoidKeyword: TSVoidKeywordBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property tupleTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  tupleTypeAnnotation: TupleTypeAnnotationBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property typeAlias

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    typeAlias: TypeAliasBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property typeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      typeAnnotation: TypeAnnotationBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property typeCastExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        typeCastExpression: TypeCastExpressionBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property typeofTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          typeofTypeAnnotation: TypeofTypeAnnotationBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property typeParameter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            typeParameter: TypeParameterBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property typeParameterDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              typeParameterDeclaration: TypeParameterDeclarationBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property typeParameterInstantiation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                typeParameterInstantiation: TypeParameterInstantiationBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property unaryExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  unaryExpression: UnaryExpressionBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property unionTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    unionTypeAnnotation: UnionTypeAnnotationBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property updateExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      updateExpression: UpdateExpressionBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property variableDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        variableDeclaration: VariableDeclarationBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property variableDeclarator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          variableDeclarator: VariableDeclaratorBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property variance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            variance: VarianceBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property voidTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              voidTypeAnnotation: VoidTypeAnnotationBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property whileStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                whileStatement: WhileStatementBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property withStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  withStatement: WithStatementBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property yieldExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    yieldExpression: YieldExpressionBuilder;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [builderName: string]: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface NodePath

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property node

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          node: N;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property parent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            parent: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property replace

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              replace: Path['replace'];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property scope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                scope: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method canBeFirstInStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  canBeFirstInStatement: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method firstInStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    firstInStatement: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getValueProperty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getValueProperty: (name: any) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method needsParens

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method prune

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface Visitor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface Visitor<M = {}> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method visitAnyTypeAnnotation

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method visitArrayExpression

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method visitArrayPattern

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method visitArrayTypeAnnotation

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method visitArrowFunctionExpression

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method visitAssignmentExpression

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method visitAssignmentPattern

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method visitAwaitExpression

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method visitBigIntLiteral

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method visitBigIntLiteralTypeAnnotation

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method visitBigIntTypeAnnotation

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method visitBinaryExpression

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method visitBindExpression

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method visitBlock

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method visitBlockStatement

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method visitBooleanLiteral

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method visitBooleanLiteralTypeAnnotation

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method visitBooleanTypeAnnotation

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method visitBreakStatement

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method visitCallExpression

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method visitCatchClause

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method visitChainElement

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method visitChainExpression

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method visitClassBody

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method visitClassDeclaration

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method visitClassExpression

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method visitClassImplements

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method visitClassMethod

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method visitClassPrivateMethod

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method visitClassPrivateProperty

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method visitClassProperty

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method visitClassPropertyDefinition

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method visitComment

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method visitCommentBlock

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method visitCommentLine

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method visitComprehensionBlock

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method visitComprehensionExpression

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method visitConditionalExpression

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method visitContinueStatement

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method visitDebuggerStatement

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method visitDeclaration

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method visitDeclareClass

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method visitDeclaredPredicate

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method visitDeclareExportAllDeclaration

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method visitDeclareExportDeclaration

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method visitDeclareFunction

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method visitDeclareInterface

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method visitDeclareModule

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method visitDeclareModuleExports

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method visitDeclareOpaqueType

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method visitDeclareTypeAlias

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method visitDeclareVariable

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method visitDecorator

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method visitDirective

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method visitDirectiveLiteral

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method visitDoExpression

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method visitDoWhileStatement

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method visitEmptyStatement

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method visitEmptyTypeAnnotation

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method visitEnumBooleanBody

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method visitEnumBooleanMember

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method visitEnumDeclaration

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method visitEnumDefaultedMember

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method visitEnumNumberBody

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method visitEnumNumberMember

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method visitEnumStringBody

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method visitEnumStringMember

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method visitEnumSymbolBody

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method visitExistentialTypeParam

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method visitExistsTypeAnnotation

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method visitExportAllDeclaration

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method visitExportBatchSpecifier

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method visitExportDeclaration

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method visitExportDefaultDeclaration

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method visitExportDefaultSpecifier

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method visitExportNamedDeclaration

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method visitExportNamespaceSpecifier

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method visitExportSpecifier

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method visitExpression

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method visitExpressionStatement

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method visitFile

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method visitFlow

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method visitFlowPredicate

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method visitFlowType

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method visitForAwaitStatement

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method visitForInStatement

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method visitForOfStatement

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method visitForStatement

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method visitFunction

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method visitFunctionDeclaration

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method visitFunctionExpression

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method visitFunctionTypeAnnotation

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method visitFunctionTypeParam

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method visitGeneratorExpression

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method visitGenericTypeAnnotation

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method visitIdentifier

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method visitIfStatement

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method visitImport

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method visitImportDeclaration

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method visitImportDefaultSpecifier

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method visitImportExpression

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method visitImportNamespaceSpecifier

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method visitImportSpecifier

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method visitInferredPredicate

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method visitInterfaceDeclaration

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method visitInterfaceExtends

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method visitInterfaceTypeAnnotation

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method visitInterpreterDirective

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method visitIntersectionTypeAnnotation

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method visitJSXAttribute

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method visitJSXClosingElement

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method visitJSXClosingFragment

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method visitJSXElement

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method visitJSXEmptyExpression

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method visitJSXExpressionContainer

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method visitJSXFragment

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method visitJSXIdentifier

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method visitJSXMemberExpression

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method visitJSXNamespacedName

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method visitJSXOpeningElement

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method visitJSXOpeningFragment

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method visitJSXSpreadAttribute

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method visitJSXSpreadChild

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method visitJSXText

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method visitLabeledStatement

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method visitLine

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method visitLiteral

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method visitLogicalExpression

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method visitMemberExpression

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method visitMemberTypeAnnotation

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method visitMetaProperty

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method visitMethodDefinition

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method visitMixedTypeAnnotation

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method visitModuleSpecifier

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method visitNewExpression

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method visitNode

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method visitNoop

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method visitNullableTypeAnnotation

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method visitNullLiteral

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method visitNullLiteralTypeAnnotation

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method visitNullTypeAnnotation

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method visitNumberLiteralTypeAnnotation

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method visitNumberTypeAnnotation

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method visitNumericLiteral

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method visitNumericLiteralTypeAnnotation

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method visitObjectExpression

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method visitObjectMethod

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method visitObjectPattern

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method visitObjectProperty

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method visitObjectTypeAnnotation

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method visitObjectTypeCallProperty

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method visitObjectTypeIndexer

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method visitObjectTypeInternalSlot

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method visitObjectTypeProperty

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method visitObjectTypeSpreadProperty

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method visitOpaqueType

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method visitOptionalCallExpression

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method visitOptionalMemberExpression

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method visitParenthesizedExpression

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method visitPattern

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method visitPosition

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method visitPrintable

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method visitPrivateName

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method visitProgram

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method visitProperty

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method visitPropertyPattern

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method visitQualifiedTypeIdentifier

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method visitRegExpLiteral

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method visitRestElement

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method visitRestProperty

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method visitReturnStatement

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method visitSequenceExpression

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method visitSourceLocation

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method visitSpecifier

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method visitSpreadElement

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method visitSpreadElementPattern

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method visitSpreadProperty

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method visitSpreadPropertyPattern

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method visitStatement

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method visitStringLiteral

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method visitStringLiteralTypeAnnotation

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method visitStringTypeAnnotation

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method visitSuper

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method visitSwitchCase

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method visitSwitchStatement

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method visitSymbolTypeAnnotation

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method visitTaggedTemplateExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  visitTaggedTemplateExpression: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  this: Context & M,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  path: