@types/babel-traverse

  • Version 6.25.5
  • Published
  • 49.6 kB
  • 1 dependency
  • MIT license

Install

npm i @types/babel-traverse
yarn add @types/babel-traverse
pnpm add @types/babel-traverse

Overview

TypeScript definitions for babel-traverse

Index

Functions

Classes

Interfaces

Type Aliases

Functions

function traverse

traverse: {
<S>(
parent: Node | Node[],
opts: TraverseOptions<S>,
scope: Scope,
state: S,
parentPath?: NodePath
): void;
(
parent: any,
opts: TraverseOptions<any>,
scope?: Scope,
state?: any,
parentPath?: NodePath<any>
): void;
};

    Classes

    class Binding

    class Binding {}

      constructor

      constructor(opts: {
      existing: Binding;
      identifier: any;
      scope: Scope;
      path: NodePath;
      kind: 'var' | 'let' | 'const';
      });

        property constant

        constant: boolean;

          property constantViolations

          constantViolations: NodePath<any>[];

            property identifier

            identifier: any;

              property kind

              kind: 'var' | 'let' | 'const' | 'module';

                property path

                path: NodePath<any>;

                  property referenced

                  referenced: boolean;

                    property referencePaths

                    referencePaths: NodePath<any>[];

                      property references

                      references: number;

                        property scope

                        scope: Scope;

                          class Hub

                          class Hub {}

                            constructor

                            constructor(file: any, options: any);

                              property file

                              file: any;

                                property options

                                options: any;

                                  class NodePath

                                  class NodePath<T = Node> {}

                                    constructor

                                    constructor(hub: Hub, parent: any);

                                      property container

                                      container: object | object[];

                                        property context

                                        context: TraversalContext;

                                          property contexts

                                          contexts: TraversalContext[];

                                            property data

                                            data: {};

                                              property hub

                                              hub: Hub;

                                                property inList

                                                inList: boolean;

                                                  property key

                                                  key: string | number;

                                                    property listKey

                                                    listKey: string;

                                                      property node

                                                      node: {};

                                                        property opts

                                                        opts: {};

                                                          property parent

                                                          parent: any;

                                                            property parentKey

                                                            parentKey: string;

                                                              property parentPath

                                                              parentPath: NodePath<any>;

                                                                property removed

                                                                removed: boolean;

                                                                  property scope

                                                                  scope: Scope;

                                                                    property shouldSkip

                                                                    shouldSkip: boolean;

                                                                      property shouldStop

                                                                      shouldStop: boolean;

                                                                        property skipKeys

                                                                        skipKeys: {};

                                                                          property state

                                                                          state: any;

                                                                            property type

                                                                            type: string;

                                                                              property typeAnnotation

                                                                              typeAnnotation: {};

                                                                                method addComment

                                                                                addComment: (type: string, content: string, line?: boolean) => void;

                                                                                  method addComments

                                                                                  addComments: (type: string, comments: any[]) => void;
                                                                                  • Give node comments of the specified type.

                                                                                  method assertAnyTypeAnnotation

                                                                                  assertAnyTypeAnnotation: (opts?: object) => void;

                                                                                    method assertArrayExpression

                                                                                    assertArrayExpression: (opts?: object) => void;

                                                                                      method assertArrayPattern

                                                                                      assertArrayPattern: (opts?: object) => void;

                                                                                        method assertArrayTypeAnnotation

                                                                                        assertArrayTypeAnnotation: (opts?: object) => void;

                                                                                          method assertArrowFunctionExpression

                                                                                          assertArrowFunctionExpression: (opts?: object) => void;

                                                                                            method assertAssignmentExpression

                                                                                            assertAssignmentExpression: (opts?: object) => void;

                                                                                              method assertAssignmentPattern

                                                                                              assertAssignmentPattern: (opts?: object) => void;

                                                                                                method assertAwaitExpression

                                                                                                assertAwaitExpression: (opts?: object) => void;

                                                                                                  method assertBinary

                                                                                                  assertBinary: (opts?: object) => void;

                                                                                                    method assertBinaryExpression

                                                                                                    assertBinaryExpression: (opts?: object) => void;

                                                                                                      method assertBindExpression

                                                                                                      assertBindExpression: (opts?: object) => void;

                                                                                                        method assertBlock

                                                                                                        assertBlock: (opts?: object) => void;

                                                                                                          method assertBlockParent

                                                                                                          assertBlockParent: (opts?: object) => void;

                                                                                                            method assertBlockStatement

                                                                                                            assertBlockStatement: (opts?: object) => void;

                                                                                                              method assertBooleanLiteral

                                                                                                              assertBooleanLiteral: (opts?: object) => void;

                                                                                                                method assertBooleanLiteralTypeAnnotation

                                                                                                                assertBooleanLiteralTypeAnnotation: (opts?: object) => void;

                                                                                                                  method assertBooleanTypeAnnotation

                                                                                                                  assertBooleanTypeAnnotation: (opts?: object) => void;

                                                                                                                    method assertBreakStatement

                                                                                                                    assertBreakStatement: (opts?: object) => void;

                                                                                                                      method assertCallExpression

                                                                                                                      assertCallExpression: (opts?: object) => void;

                                                                                                                        method assertCatchClause

                                                                                                                        assertCatchClause: (opts?: object) => void;

                                                                                                                          method assertClass

                                                                                                                          assertClass: (opts?: object) => void;

                                                                                                                            method assertClassBody

                                                                                                                            assertClassBody: (opts?: object) => void;

                                                                                                                              method assertClassDeclaration

                                                                                                                              assertClassDeclaration: (opts?: object) => void;

                                                                                                                                method assertClassExpression

                                                                                                                                assertClassExpression: (opts?: object) => void;

                                                                                                                                  method assertClassImplements

                                                                                                                                  assertClassImplements: (opts?: object) => void;

                                                                                                                                    method assertClassMethod

                                                                                                                                    assertClassMethod: (opts?: object) => void;

                                                                                                                                      method assertClassProperty

                                                                                                                                      assertClassProperty: (opts?: object) => void;

                                                                                                                                        method assertCompletionStatement

                                                                                                                                        assertCompletionStatement: (opts?: object) => void;

                                                                                                                                          method assertConditional

                                                                                                                                          assertConditional: (opts?: object) => void;

                                                                                                                                            method assertConditionalExpression

                                                                                                                                            assertConditionalExpression: (opts?: object) => void;

                                                                                                                                              method assertContinueStatement

                                                                                                                                              assertContinueStatement: (opts?: object) => void;

                                                                                                                                                method assertDebuggerStatement

                                                                                                                                                assertDebuggerStatement: (opts?: object) => void;

                                                                                                                                                  method assertDeclaration

                                                                                                                                                  assertDeclaration: (opts?: object) => void;

                                                                                                                                                    method assertDeclareClass

                                                                                                                                                    assertDeclareClass: (opts?: object) => void;

                                                                                                                                                      method assertDeclareFunction

                                                                                                                                                      assertDeclareFunction: (opts?: object) => void;

                                                                                                                                                        method assertDeclareInterface

                                                                                                                                                        assertDeclareInterface: (opts?: object) => void;

                                                                                                                                                          method assertDeclareModule

                                                                                                                                                          assertDeclareModule: (opts?: object) => void;

                                                                                                                                                            method assertDeclareTypeAlias

                                                                                                                                                            assertDeclareTypeAlias: (opts?: object) => void;

                                                                                                                                                              method assertDeclareVariable

                                                                                                                                                              assertDeclareVariable: (opts?: object) => void;

                                                                                                                                                                method assertDecorator

                                                                                                                                                                assertDecorator: (opts?: object) => void;

                                                                                                                                                                  method assertDirective

                                                                                                                                                                  assertDirective: (opts?: object) => void;

                                                                                                                                                                    method assertDirectiveLiteral

                                                                                                                                                                    assertDirectiveLiteral: (opts?: object) => void;

                                                                                                                                                                      method assertDoExpression

                                                                                                                                                                      assertDoExpression: (opts?: object) => void;

                                                                                                                                                                        method assertDoWhileStatement

                                                                                                                                                                        assertDoWhileStatement: (opts?: object) => void;

                                                                                                                                                                          method assertEmptyStatement

                                                                                                                                                                          assertEmptyStatement: (opts?: object) => void;

                                                                                                                                                                            method assertExistentialTypeParam

                                                                                                                                                                            assertExistentialTypeParam: (opts?: object) => void;

                                                                                                                                                                              method assertExportAllDeclaration

                                                                                                                                                                              assertExportAllDeclaration: (opts?: object) => void;

                                                                                                                                                                                method assertExportDeclaration

                                                                                                                                                                                assertExportDeclaration: (opts?: object) => void;

                                                                                                                                                                                  method assertExportDefaultDeclaration

                                                                                                                                                                                  assertExportDefaultDeclaration: (opts?: object) => void;

                                                                                                                                                                                    method assertExportDefaultSpecifier

                                                                                                                                                                                    assertExportDefaultSpecifier: (opts?: object) => void;

                                                                                                                                                                                      method assertExportNamedDeclaration

                                                                                                                                                                                      assertExportNamedDeclaration: (opts?: object) => void;

                                                                                                                                                                                        method assertExportNamespaceSpecifier

                                                                                                                                                                                        assertExportNamespaceSpecifier: (opts?: object) => void;

                                                                                                                                                                                          method assertExportSpecifier

                                                                                                                                                                                          assertExportSpecifier: (opts?: object) => void;

                                                                                                                                                                                            method assertExpression

                                                                                                                                                                                            assertExpression: (opts?: object) => void;

                                                                                                                                                                                              method assertExpressionStatement

                                                                                                                                                                                              assertExpressionStatement: (opts?: object) => void;

                                                                                                                                                                                                method assertExpressionWrapper

                                                                                                                                                                                                assertExpressionWrapper: (opts?: object) => void;

                                                                                                                                                                                                  method assertFile

                                                                                                                                                                                                  assertFile: (opts?: object) => void;

                                                                                                                                                                                                    method assertFlow

                                                                                                                                                                                                    assertFlow: (opts?: object) => void;

                                                                                                                                                                                                      method assertFlowBaseAnnotation

                                                                                                                                                                                                      assertFlowBaseAnnotation: (opts?: object) => void;

                                                                                                                                                                                                        method assertFlowDeclaration

                                                                                                                                                                                                        assertFlowDeclaration: (opts?: object) => void;

                                                                                                                                                                                                          method assertFor

                                                                                                                                                                                                          assertFor: (opts?: object) => void;

                                                                                                                                                                                                            method assertForInStatement

                                                                                                                                                                                                            assertForInStatement: (opts?: object) => void;

                                                                                                                                                                                                              method assertForOfStatement

                                                                                                                                                                                                              assertForOfStatement: (opts?: object) => void;

                                                                                                                                                                                                                method assertForStatement

                                                                                                                                                                                                                assertForStatement: (opts?: object) => void;

                                                                                                                                                                                                                  method assertForXStatement

                                                                                                                                                                                                                  assertForXStatement: (opts?: object) => void;

                                                                                                                                                                                                                    method assertFunction

                                                                                                                                                                                                                    assertFunction: (opts?: object) => void;

                                                                                                                                                                                                                      method assertFunctionDeclaration

                                                                                                                                                                                                                      assertFunctionDeclaration: (opts?: object) => void;

                                                                                                                                                                                                                        method assertFunctionExpression

                                                                                                                                                                                                                        assertFunctionExpression: (opts?: object) => void;

                                                                                                                                                                                                                          method assertFunctionParent

                                                                                                                                                                                                                          assertFunctionParent: (opts?: object) => void;

                                                                                                                                                                                                                            method assertFunctionTypeAnnotation

                                                                                                                                                                                                                            assertFunctionTypeAnnotation: (opts?: object) => void;

                                                                                                                                                                                                                              method assertFunctionTypeParam

                                                                                                                                                                                                                              assertFunctionTypeParam: (opts?: object) => void;

                                                                                                                                                                                                                                method assertGenericTypeAnnotation

                                                                                                                                                                                                                                assertGenericTypeAnnotation: (opts?: object) => void;

                                                                                                                                                                                                                                  method assertIdentifier

                                                                                                                                                                                                                                  assertIdentifier: (opts?: object) => void;

                                                                                                                                                                                                                                    method assertIfStatement

                                                                                                                                                                                                                                    assertIfStatement: (opts?: object) => void;

                                                                                                                                                                                                                                      method assertImmutable

                                                                                                                                                                                                                                      assertImmutable: (opts?: object) => void;

                                                                                                                                                                                                                                        method assertImportDeclaration

                                                                                                                                                                                                                                        assertImportDeclaration: (opts?: object) => void;

                                                                                                                                                                                                                                          method assertImportDefaultSpecifier

                                                                                                                                                                                                                                          assertImportDefaultSpecifier: (opts?: object) => void;

                                                                                                                                                                                                                                            method assertImportNamespaceSpecifier

                                                                                                                                                                                                                                            assertImportNamespaceSpecifier: (opts?: object) => void;

                                                                                                                                                                                                                                              method assertImportSpecifier

                                                                                                                                                                                                                                              assertImportSpecifier: (opts?: object) => void;

                                                                                                                                                                                                                                                method assertInterfaceDeclaration

                                                                                                                                                                                                                                                assertInterfaceDeclaration: (opts?: object) => void;

                                                                                                                                                                                                                                                  method assertInterfaceExtends

                                                                                                                                                                                                                                                  assertInterfaceExtends: (opts?: object) => void;

                                                                                                                                                                                                                                                    method assertIntersectionTypeAnnotation

                                                                                                                                                                                                                                                    assertIntersectionTypeAnnotation: (opts?: object) => void;

                                                                                                                                                                                                                                                      method assertJSX

                                                                                                                                                                                                                                                      assertJSX: (opts?: object) => void;

                                                                                                                                                                                                                                                        method assertJSXAttribute

                                                                                                                                                                                                                                                        assertJSXAttribute: (opts?: object) => void;

                                                                                                                                                                                                                                                          method assertJSXClosingElement

                                                                                                                                                                                                                                                          assertJSXClosingElement: (opts?: object) => void;

                                                                                                                                                                                                                                                            method assertJSXElement

                                                                                                                                                                                                                                                            assertJSXElement: (opts?: object) => void;

                                                                                                                                                                                                                                                              method assertJSXEmptyExpression

                                                                                                                                                                                                                                                              assertJSXEmptyExpression: (opts?: object) => void;

                                                                                                                                                                                                                                                                method assertJSXExpressionContainer

                                                                                                                                                                                                                                                                assertJSXExpressionContainer: (opts?: object) => void;

                                                                                                                                                                                                                                                                  method assertJSXIdentifier

                                                                                                                                                                                                                                                                  assertJSXIdentifier: (opts?: object) => void;

                                                                                                                                                                                                                                                                    method assertJSXMemberExpression

                                                                                                                                                                                                                                                                    assertJSXMemberExpression: (opts?: object) => void;

                                                                                                                                                                                                                                                                      method assertJSXNamespacedName

                                                                                                                                                                                                                                                                      assertJSXNamespacedName: (opts?: object) => void;

                                                                                                                                                                                                                                                                        method assertJSXOpeningElement

                                                                                                                                                                                                                                                                        assertJSXOpeningElement: (opts?: object) => void;

                                                                                                                                                                                                                                                                          method assertJSXSpreadAttribute

                                                                                                                                                                                                                                                                          assertJSXSpreadAttribute: (opts?: object) => void;

                                                                                                                                                                                                                                                                            method assertJSXText

                                                                                                                                                                                                                                                                            assertJSXText: (opts?: object) => void;

                                                                                                                                                                                                                                                                              method assertLabeledStatement

                                                                                                                                                                                                                                                                              assertLabeledStatement: (opts?: object) => void;

                                                                                                                                                                                                                                                                                method assertLiteral

                                                                                                                                                                                                                                                                                assertLiteral: (opts?: object) => void;

                                                                                                                                                                                                                                                                                  method assertLogicalExpression

                                                                                                                                                                                                                                                                                  assertLogicalExpression: (opts?: object) => void;

                                                                                                                                                                                                                                                                                    method assertLoop

                                                                                                                                                                                                                                                                                    assertLoop: (opts?: object) => void;

                                                                                                                                                                                                                                                                                      method assertLVal

                                                                                                                                                                                                                                                                                      assertLVal: (opts?: object) => void;

                                                                                                                                                                                                                                                                                        method assertMemberExpression

                                                                                                                                                                                                                                                                                        assertMemberExpression: (opts?: object) => void;

                                                                                                                                                                                                                                                                                          method assertMetaProperty

                                                                                                                                                                                                                                                                                          assertMetaProperty: (opts?: object) => void;

                                                                                                                                                                                                                                                                                            method assertMethod

                                                                                                                                                                                                                                                                                            assertMethod: (opts?: object) => void;

                                                                                                                                                                                                                                                                                              method assertMixedTypeAnnotation

                                                                                                                                                                                                                                                                                              assertMixedTypeAnnotation: (opts?: object) => void;

                                                                                                                                                                                                                                                                                                method assertModuleDeclaration

                                                                                                                                                                                                                                                                                                assertModuleDeclaration: (opts?: object) => void;

                                                                                                                                                                                                                                                                                                  method assertModuleSpecifier

                                                                                                                                                                                                                                                                                                  assertModuleSpecifier: (opts?: object) => void;

                                                                                                                                                                                                                                                                                                    method assertNewExpression

                                                                                                                                                                                                                                                                                                    assertNewExpression: (opts?: object) => void;

                                                                                                                                                                                                                                                                                                      method assertNoop

                                                                                                                                                                                                                                                                                                      assertNoop: (opts?: object) => void;

                                                                                                                                                                                                                                                                                                        method assertNullableTypeAnnotation

                                                                                                                                                                                                                                                                                                        assertNullableTypeAnnotation: (opts?: object) => void;

                                                                                                                                                                                                                                                                                                          method assertNullLiteral

                                                                                                                                                                                                                                                                                                          assertNullLiteral: (opts?: object) => void;

                                                                                                                                                                                                                                                                                                            method assertNullLiteralTypeAnnotation

                                                                                                                                                                                                                                                                                                            assertNullLiteralTypeAnnotation: (opts?: object) => void;

                                                                                                                                                                                                                                                                                                              method assertNumberLiteral

                                                                                                                                                                                                                                                                                                              assertNumberLiteral: (opts?: object) => void;

                                                                                                                                                                                                                                                                                                                method assertNumberTypeAnnotation

                                                                                                                                                                                                                                                                                                                assertNumberTypeAnnotation: (opts?: object) => void;

                                                                                                                                                                                                                                                                                                                  method assertNumericLiteral

                                                                                                                                                                                                                                                                                                                  assertNumericLiteral: (opts?: object) => void;

                                                                                                                                                                                                                                                                                                                    method assertNumericLiteralTypeAnnotation

                                                                                                                                                                                                                                                                                                                    assertNumericLiteralTypeAnnotation: (opts?: object) => void;

                                                                                                                                                                                                                                                                                                                      method assertObjectExpression

                                                                                                                                                                                                                                                                                                                      assertObjectExpression: (opts?: object) => void;

                                                                                                                                                                                                                                                                                                                        method assertObjectMember

                                                                                                                                                                                                                                                                                                                        assertObjectMember: (opts?: object) => void;

                                                                                                                                                                                                                                                                                                                          method assertObjectMethod

                                                                                                                                                                                                                                                                                                                          assertObjectMethod: (opts?: object) => void;

                                                                                                                                                                                                                                                                                                                            method assertObjectPattern

                                                                                                                                                                                                                                                                                                                            assertObjectPattern: (opts?: object) => void;

                                                                                                                                                                                                                                                                                                                              method assertObjectProperty

                                                                                                                                                                                                                                                                                                                              assertObjectProperty: (opts?: object) => void;

                                                                                                                                                                                                                                                                                                                                method assertObjectTypeAnnotation

                                                                                                                                                                                                                                                                                                                                assertObjectTypeAnnotation: (opts?: object) => void;

                                                                                                                                                                                                                                                                                                                                  method assertObjectTypeCallProperty

                                                                                                                                                                                                                                                                                                                                  assertObjectTypeCallProperty: (opts?: object) => void;

                                                                                                                                                                                                                                                                                                                                    method assertObjectTypeIndexer

                                                                                                                                                                                                                                                                                                                                    assertObjectTypeIndexer: (opts?: object) => void;

                                                                                                                                                                                                                                                                                                                                      method assertObjectTypeProperty

                                                                                                                                                                                                                                                                                                                                      assertObjectTypeProperty: (opts?: object) => void;

                                                                                                                                                                                                                                                                                                                                        method assertParenthesizedExpression

                                                                                                                                                                                                                                                                                                                                        assertParenthesizedExpression: (opts?: object) => void;

                                                                                                                                                                                                                                                                                                                                          method assertPattern

                                                                                                                                                                                                                                                                                                                                          assertPattern: (opts?: object) => void;

                                                                                                                                                                                                                                                                                                                                            method assertProgram

                                                                                                                                                                                                                                                                                                                                            assertProgram: (opts?: object) => void;

                                                                                                                                                                                                                                                                                                                                              method assertProperty

                                                                                                                                                                                                                                                                                                                                              assertProperty: (opts?: object) => void;

                                                                                                                                                                                                                                                                                                                                                method assertPureish

                                                                                                                                                                                                                                                                                                                                                assertPureish: (opts?: object) => void;

                                                                                                                                                                                                                                                                                                                                                  method assertQualifiedTypeIdentifier

                                                                                                                                                                                                                                                                                                                                                  assertQualifiedTypeIdentifier: (opts?: object) => void;

                                                                                                                                                                                                                                                                                                                                                    method assertRegexLiteral

                                                                                                                                                                                                                                                                                                                                                    assertRegexLiteral: (opts?: object) => void;

                                                                                                                                                                                                                                                                                                                                                      method assertRegExpLiteral

                                                                                                                                                                                                                                                                                                                                                      assertRegExpLiteral: (opts?: object) => void;

                                                                                                                                                                                                                                                                                                                                                        method assertRestElement

                                                                                                                                                                                                                                                                                                                                                        assertRestElement: (opts?: object) => void;

                                                                                                                                                                                                                                                                                                                                                          method assertRestProperty

                                                                                                                                                                                                                                                                                                                                                          assertRestProperty: (opts?: object) => void;

                                                                                                                                                                                                                                                                                                                                                            method assertReturnStatement

                                                                                                                                                                                                                                                                                                                                                            assertReturnStatement: (opts?: object) => void;

                                                                                                                                                                                                                                                                                                                                                              method assertScopable

                                                                                                                                                                                                                                                                                                                                                              assertScopable: (opts?: object) => void;

                                                                                                                                                                                                                                                                                                                                                                method assertSequenceExpression

                                                                                                                                                                                                                                                                                                                                                                assertSequenceExpression: (opts?: object) => void;

                                                                                                                                                                                                                                                                                                                                                                  method assertSpreadElement

                                                                                                                                                                                                                                                                                                                                                                  assertSpreadElement: (opts?: object) => void;

                                                                                                                                                                                                                                                                                                                                                                    method assertSpreadProperty

                                                                                                                                                                                                                                                                                                                                                                    assertSpreadProperty: (opts?: object) => void;

                                                                                                                                                                                                                                                                                                                                                                      method assertStatement

                                                                                                                                                                                                                                                                                                                                                                      assertStatement: (opts?: object) => void;

                                                                                                                                                                                                                                                                                                                                                                        method assertStringLiteral

                                                                                                                                                                                                                                                                                                                                                                        assertStringLiteral: (opts?: object) => void;

                                                                                                                                                                                                                                                                                                                                                                          method assertStringLiteralTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                          assertStringLiteralTypeAnnotation: (opts?: object) => void;

                                                                                                                                                                                                                                                                                                                                                                            method assertStringTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                            assertStringTypeAnnotation: (opts?: object) => void;

                                                                                                                                                                                                                                                                                                                                                                              method assertSuper

                                                                                                                                                                                                                                                                                                                                                                              assertSuper: (opts?: object) => void;

                                                                                                                                                                                                                                                                                                                                                                                method assertSwitchCase

                                                                                                                                                                                                                                                                                                                                                                                assertSwitchCase: (opts?: object) => void;

                                                                                                                                                                                                                                                                                                                                                                                  method assertSwitchStatement

                                                                                                                                                                                                                                                                                                                                                                                  assertSwitchStatement: (opts?: object) => void;

                                                                                                                                                                                                                                                                                                                                                                                    method assertTaggedTemplateExpression

                                                                                                                                                                                                                                                                                                                                                                                    assertTaggedTemplateExpression: (opts?: object) => void;

                                                                                                                                                                                                                                                                                                                                                                                      method assertTemplateElement

                                                                                                                                                                                                                                                                                                                                                                                      assertTemplateElement: (opts?: object) => void;

                                                                                                                                                                                                                                                                                                                                                                                        method assertTemplateLiteral

                                                                                                                                                                                                                                                                                                                                                                                        assertTemplateLiteral: (opts?: object) => void;

                                                                                                                                                                                                                                                                                                                                                                                          method assertTerminatorless

                                                                                                                                                                                                                                                                                                                                                                                          assertTerminatorless: (opts?: object) => void;

                                                                                                                                                                                                                                                                                                                                                                                            method assertThisExpression

                                                                                                                                                                                                                                                                                                                                                                                            assertThisExpression: (opts?: object) => void;

                                                                                                                                                                                                                                                                                                                                                                                              method assertThisTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                              assertThisTypeAnnotation: (opts?: object) => void;

                                                                                                                                                                                                                                                                                                                                                                                                method assertThrowStatement

                                                                                                                                                                                                                                                                                                                                                                                                assertThrowStatement: (opts?: object) => void;

                                                                                                                                                                                                                                                                                                                                                                                                  method assertTryStatement

                                                                                                                                                                                                                                                                                                                                                                                                  assertTryStatement: (opts?: object) => void;

                                                                                                                                                                                                                                                                                                                                                                                                    method assertTupleTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                    assertTupleTypeAnnotation: (opts?: object) => void;

                                                                                                                                                                                                                                                                                                                                                                                                      method assertTypeAlias

                                                                                                                                                                                                                                                                                                                                                                                                      assertTypeAlias: (opts?: object) => void;

                                                                                                                                                                                                                                                                                                                                                                                                        method assertTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                        assertTypeAnnotation: (opts?: object) => void;

                                                                                                                                                                                                                                                                                                                                                                                                          method assertTypeCastExpression

                                                                                                                                                                                                                                                                                                                                                                                                          assertTypeCastExpression: (opts?: object) => void;

                                                                                                                                                                                                                                                                                                                                                                                                            method assertTypeofTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                            assertTypeofTypeAnnotation: (opts?: object) => void;

                                                                                                                                                                                                                                                                                                                                                                                                              method assertTypeParameterDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                              assertTypeParameterDeclaration: (opts?: object) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                method assertTypeParameterInstantiation

                                                                                                                                                                                                                                                                                                                                                                                                                assertTypeParameterInstantiation: (opts?: object) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                  method assertUnaryExpression

                                                                                                                                                                                                                                                                                                                                                                                                                  assertUnaryExpression: (opts?: object) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                    method assertUnaryLike

                                                                                                                                                                                                                                                                                                                                                                                                                    assertUnaryLike: (opts?: object) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                      method assertUnionTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                      assertUnionTypeAnnotation: (opts?: object) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                        method assertUpdateExpression

                                                                                                                                                                                                                                                                                                                                                                                                                        assertUpdateExpression: (opts?: object) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                          method assertUserWhitespacable

                                                                                                                                                                                                                                                                                                                                                                                                                          assertUserWhitespacable: (opts?: object) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                            method assertVariableDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                            assertVariableDeclaration: (opts?: object) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                              method assertVariableDeclarator

                                                                                                                                                                                                                                                                                                                                                                                                                              assertVariableDeclarator: (opts?: object) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                method assertVoidTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                assertVoidTypeAnnotation: (opts?: object) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                  method assertWhile

                                                                                                                                                                                                                                                                                                                                                                                                                                  assertWhile: (opts?: object) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                    method assertWhileStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                    assertWhileStatement: (opts?: object) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                      method assertWithStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                      assertWithStatement: (opts?: object) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                        method assertYieldExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                        assertYieldExpression: (opts?: object) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                          method baseTypeStrictlyMatches

                                                                                                                                                                                                                                                                                                                                                                                                                                          baseTypeStrictlyMatches: (right: NodePath) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                            method buildCodeFrameError

                                                                                                                                                                                                                                                                                                                                                                                                                                            buildCodeFrameError: <TError extends Error>(
                                                                                                                                                                                                                                                                                                                                                                                                                                            msg: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                            Error?: new (msg: string) => TError
                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => TError;

                                                                                                                                                                                                                                                                                                                                                                                                                                              method call

                                                                                                                                                                                                                                                                                                                                                                                                                                              call: (key: string) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                method canHaveVariableDeclarationOrExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                canHaveVariableDeclarationOrExpression: () => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                • This checks whether or not we're in one of the following positions:

                                                                                                                                                                                                                                                                                                                                                                                                                                                  for (KEY in right); for (KEY;;);

                                                                                                                                                                                                                                                                                                                                                                                                                                                  This is because these spots allow VariableDeclarations AND normal expressions so we need to tell the path replacement that it's ok to replace this with an expression.

                                                                                                                                                                                                                                                                                                                                                                                                                                                method canSwapBetweenExpressionAndStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                canSwapBetweenExpressionAndStatement: (replacement: any) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                • This checks whether we are swapping an arrow function's body between an expression and a block statement (or vice versa).

                                                                                                                                                                                                                                                                                                                                                                                                                                                  This is because arrow functions may implicitly return an expression, which is the same as containing a block statement.

                                                                                                                                                                                                                                                                                                                                                                                                                                                method couldBeBaseType

                                                                                                                                                                                                                                                                                                                                                                                                                                                couldBeBaseType: (name: string) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  method debug

                                                                                                                                                                                                                                                                                                                                                                                                                                                  debug: (buildMessage: () => string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    method equals

                                                                                                                                                                                                                                                                                                                                                                                                                                                    equals: (key: string, value: any) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Check whether the path node key strict equals value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                    method evaluate

                                                                                                                                                                                                                                                                                                                                                                                                                                                    evaluate: () => { confident: boolean; value: any };
                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Walk the input node and statically evaluate it.

                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns an object in the form { confident, value }. confident indicates whether or not we had to drop out of evaluating the expression because of hitting an unknown node that we couldn't confidently find the value of.

                                                                                                                                                                                                                                                                                                                                                                                                                                                      Example:

                                                                                                                                                                                                                                                                                                                                                                                                                                                      t.evaluate(parse("5 + 5")) // { confident: true, value: 10 } t.evaluate(parse("!true")) // { confident: true, value: false } t.evaluate(parse("foo + foo")) // { confident: false, value: undefined }

                                                                                                                                                                                                                                                                                                                                                                                                                                                    method evaluateTruthy

                                                                                                                                                                                                                                                                                                                                                                                                                                                    evaluateTruthy: () => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Walk the input node and statically evaluate if it's truthy.

                                                                                                                                                                                                                                                                                                                                                                                                                                                      Returning true when we're sure that the expression will evaluate to a truthy value, false if we're sure that it will evaluate to a falsy value and undefined if we aren't sure. Because of this please do not rely on coercion when using this method and check with === if it's false.

                                                                                                                                                                                                                                                                                                                                                                                                                                                    method find

                                                                                                                                                                                                                                                                                                                                                                                                                                                    find: (callback: (path: NodePath) => boolean) => NodePath;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      method findParent

                                                                                                                                                                                                                                                                                                                                                                                                                                                      findParent: (callback: (path: NodePath) => boolean) => NodePath;
                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Call the provided callback with the NodePaths of all the parents. When the callback returns a truthy value, we return that node path.

                                                                                                                                                                                                                                                                                                                                                                                                                                                      method get

                                                                                                                                                                                                                                                                                                                                                                                                                                                      get: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                      <K extends keyof T>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                      key: K,
                                                                                                                                                                                                                                                                                                                                                                                                                                                      context?: boolean | TraversalContext
                                                                                                                                                                                                                                                                                                                                                                                                                                                      ): T[K] extends Array<Node | null | undefined>
                                                                                                                                                                                                                                                                                                                                                                                                                                                      ? Array<NodePath<T[K][number]>>
                                                                                                                                                                                                                                                                                                                                                                                                                                                      : T[K] extends Node | null | undefined
                                                                                                                                                                                                                                                                                                                                                                                                                                                      ? NodePath<T[K]>
                                                                                                                                                                                                                                                                                                                                                                                                                                                      : never;
                                                                                                                                                                                                                                                                                                                                                                                                                                                      (key: string, context?: boolean | TraversalContext):
                                                                                                                                                                                                                                                                                                                                                                                                                                                      | NodePath<any>
                                                                                                                                                                                                                                                                                                                                                                                                                                                      | NodePath<any>[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                                                        method getAllNextSiblings

                                                                                                                                                                                                                                                                                                                                                                                                                                                        getAllNextSiblings: () => NodePath[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                          method getAllPrevSiblings

                                                                                                                                                                                                                                                                                                                                                                                                                                                          getAllPrevSiblings: () => NodePath[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                            method getAncestry

                                                                                                                                                                                                                                                                                                                                                                                                                                                            getAncestry: () => NodePath[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Build an array of node paths containing the entire ancestry of the current node path.

                                                                                                                                                                                                                                                                                                                                                                                                                                                              NOTE: The current node path is included in this.

                                                                                                                                                                                                                                                                                                                                                                                                                                                            method getBindingIdentifiers

                                                                                                                                                                                                                                                                                                                                                                                                                                                            getBindingIdentifiers: (duplicates?: boolean) => Node[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                              method getCompletionRecords

                                                                                                                                                                                                                                                                                                                                                                                                                                                              getCompletionRecords: () => NodePath[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                method getData

                                                                                                                                                                                                                                                                                                                                                                                                                                                                getData: (key: string, def?: any) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method getDeepestCommonAncestorFrom

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  getDeepestCommonAncestorFrom: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  paths: NodePath[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  filter?: (deepest: any, i: number, ancestries: NodePath[]) => NodePath
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => NodePath;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Get the earliest path in the tree where the provided paths intersect.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method getEarliestCommonAncestorFrom

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  getEarliestCommonAncestorFrom: (paths: NodePath[]) => NodePath[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Get the deepest common ancestor and then from it, get the earliest relationship path to that ancestor.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Earliest is defined as being "before" all the other nodes in terms of list container position and visiting key.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method getFunctionParent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  getFunctionParent: () => NodePath<t.Function>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Get the parent function of the current path.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method getOpposite

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  getOpposite: () => NodePath;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method getOuterBindingIdentifiers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    getOuterBindingIdentifiers: (duplicates?: boolean) => Node[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getPathLocation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getPathLocation: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method getScope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        getScope: (scope: Scope) => Scope;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method getSibling

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getSibling: (key: string | number) => NodePath;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method getSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            getSource: () => string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Get the source code associated with this node.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method getStatementParent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            getStatementParent: () => NodePath<t.Statement>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Walk up the tree until we hit a parent node path in a list.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method getTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            getTypeAnnotation: () => any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Infer the type of the current NodePath.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method has

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            has: (key: string) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Check whether we have the input key. If the key references an array then we check if the array has any items, otherwise we just check if it's falsy.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method hoist

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            hoist: (scope: Scope) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Hoist the current node to the highest scope possible and return a UID referencing it.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method insertAfter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            insertAfter: (nodes: Node | Node[]) => any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Insert the provided nodes after the current one. When inserting nodes after an expression, ensure that the completion record is correct by pushing the current node.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method insertBefore

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            insertBefore: (nodes: Node | Node[]) => any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Insert the provided nodes before the current one.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method inType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            inType: (...candidateTypes: string[]) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method is

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              is: (key: string) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Alias of has.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isAnyTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isAnyTypeAnnotation: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isArrayExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isArrayExpression: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isArrayPattern

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isArrayPattern: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isArrayTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isArrayTypeAnnotation: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isArrowFunctionExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isArrowFunctionExpression: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method isAssignmentExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isAssignmentExpression: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isAssignmentPattern

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isAssignmentPattern: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isAwaitExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isAwaitExpression: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isBaseType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isBaseType: (baseName: string, soft?: boolean) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isBinary

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isBinary: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isBinaryExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isBinaryExpression: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isBindExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isBindExpression: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isBindingIdentifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isBindingIdentifier: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method isBlacklisted

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isBlacklisted: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isBlock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isBlock: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isBlockParent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isBlockParent: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isBlockScoped

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isBlockScoped: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isBlockStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isBlockStatement: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isBooleanLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isBooleanLiteral: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isBooleanLiteralTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isBooleanLiteralTypeAnnotation: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isBooleanTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isBooleanTypeAnnotation: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method isBreakStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isBreakStatement: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isCallExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isCallExpression: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isCatchClause

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isCatchClause: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isClass: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isClassBody

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isClassBody: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isClassDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isClassDeclaration: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isClassExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isClassExpression: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isClassImplements

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isClassImplements: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method isClassMethod

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isClassMethod: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isClassProperty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isClassProperty: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isCompletionRecord

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isCompletionRecord: (allowInsideFunction?: boolean) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Check whether the current path references a completion record

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isCompletionStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isCompletionStatement: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isConditional

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isConditional: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isConditionalExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isConditionalExpression: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isContinueStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isContinueStatement: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isDebuggerStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isDebuggerStatement: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isDeclaration: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method isDeclareClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isDeclareClass: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isDeclareFunction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isDeclareFunction: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isDeclareInterface

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isDeclareInterface: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isDeclareModule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isDeclareModule: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isDeclareTypeAlias

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isDeclareTypeAlias: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isDeclareVariable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isDeclareVariable: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isDecorator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isDecorator: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isDirective

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isDirective: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method isDirectiveLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isDirectiveLiteral: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isDoExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isDoExpression: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isDoWhileStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isDoWhileStatement: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isEmptyStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isEmptyStatement: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isExistentialTypeParam

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isExistentialTypeParam: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isExportAllDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isExportAllDeclaration: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isExportDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isExportDeclaration: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isExportDefaultDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isExportDefaultDeclaration: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method isExportDefaultSpecifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isExportDefaultSpecifier: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isExportNamedDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isExportNamedDeclaration: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isExportNamespaceSpecifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isExportNamespaceSpecifier: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isExportSpecifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isExportSpecifier: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isExpression: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isExpressionStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isExpressionStatement: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isExpressionWrapper

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isExpressionWrapper: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isFile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isFile: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method isFlow

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isFlow: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isFlowBaseAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isFlowBaseAnnotation: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isFlowDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isFlowDeclaration: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isFor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isFor: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isForInStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isForInStatement: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isForOfStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isForOfStatement: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isForStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isForStatement: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isForXStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isForXStatement: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method isFunction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isFunction: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isFunctionDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isFunctionDeclaration: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isFunctionExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isFunctionExpression: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isFunctionParent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isFunctionParent: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isFunctionTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isFunctionTypeAnnotation: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isFunctionTypeParam

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isFunctionTypeParam: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isGenerated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isGenerated: (opts?: object) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isGenericType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isGenericType: (genericName: string) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method isGenericTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isGenericTypeAnnotation: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isIdentifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isIdentifier: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isIfStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isIfStatement: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isImmutable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isImmutable: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isImportDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isImportDeclaration: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isImportDefaultSpecifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isImportDefaultSpecifier: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isImportNamespaceSpecifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isImportNamespaceSpecifier: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isImportSpecifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isImportSpecifier: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method isInterfaceDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isInterfaceDeclaration: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isInterfaceExtends

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isInterfaceExtends: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isIntersectionTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isIntersectionTypeAnnotation: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isJSX

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isJSX: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isJSXAttribute

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isJSXAttribute: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isJSXClosingElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isJSXClosingElement: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isJSXElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isJSXElement: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isJSXEmptyExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isJSXEmptyExpression: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method isJSXExpressionContainer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isJSXExpressionContainer: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isJSXIdentifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isJSXIdentifier: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isJSXMemberExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isJSXMemberExpression: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isJSXNamespacedName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isJSXNamespacedName: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isJSXOpeningElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isJSXOpeningElement: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isJSXSpreadAttribute

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isJSXSpreadAttribute: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isJSXText

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isJSXText: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isLabeledStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isLabeledStatement: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method isLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isLiteral: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isLogicalExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isLogicalExpression: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isLoop

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isLoop: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isLVal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isLVal: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isMemberExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isMemberExpression: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isMetaProperty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isMetaProperty: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isMethod

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isMethod: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isMixedTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isMixedTypeAnnotation: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method isModuleDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isModuleDeclaration: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isModuleSpecifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isModuleSpecifier: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isNewExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isNewExpression: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isNodeType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isNodeType: (type: string) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Check the type against our stored internal type of the node. This is handy when a node has been removed yet we still internally know the type and need it to calculate node replacement.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isNoop

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isNoop: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isnt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isnt: (key: string) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Opposite of has.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isNullableTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isNullableTypeAnnotation: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isNullLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isNullLiteral: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isNullLiteralTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isNullLiteralTypeAnnotation: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isNumberLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isNumberLiteral: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method isNumberTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isNumberTypeAnnotation: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isNumericLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isNumericLiteral: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isNumericLiteralTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isNumericLiteralTypeAnnotation: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isObjectExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isObjectExpression: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isObjectMember

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isObjectMember: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isObjectMethod

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isObjectMethod: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isObjectPattern

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isObjectPattern: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isObjectProperty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isObjectProperty: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method isObjectTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isObjectTypeAnnotation: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isObjectTypeCallProperty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isObjectTypeCallProperty: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isObjectTypeIndexer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isObjectTypeIndexer: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isObjectTypeProperty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isObjectTypeProperty: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isParenthesizedExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isParenthesizedExpression: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isPattern

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isPattern: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isProgram

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isProgram: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isProperty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isProperty: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method isPure

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isPure: (opts?: object) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isPureish

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isPureish: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isQualifiedTypeIdentifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isQualifiedTypeIdentifier: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isReferenced

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isReferenced: (opts?: object) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isReferencedIdentifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isReferencedIdentifier: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isReferencedMemberExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isReferencedMemberExpression: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isRegexLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isRegexLiteral: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isRegExpLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isRegExpLiteral: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method isRestElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isRestElement: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isRestProperty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isRestProperty: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isReturnStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isReturnStatement: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isScopable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isScopable: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isScope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isScope: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isSequenceExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isSequenceExpression: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isSpreadElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isSpreadElement: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isSpreadProperty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isSpreadProperty: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method isStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isStatement: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isStatementOrBlock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isStatementOrBlock: () => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Check whether or not the current key allows either a single statement or block statement so we can explode it if necessary.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isStatic

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isStatic: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isStringLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isStringLiteral: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isStringLiteralTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isStringLiteralTypeAnnotation: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isStringTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isStringTypeAnnotation: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isSuper

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isSuper: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isSwitchCase

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isSwitchCase: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isSwitchStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isSwitchStatement: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method isTaggedTemplateExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isTaggedTemplateExpression: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isTemplateElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isTemplateElement: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isTemplateLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isTemplateLiteral: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isTerminatorless

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isTerminatorless: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isThisExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isThisExpression: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isThisTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isThisTypeAnnotation: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isThrowStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isThrowStatement: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isTryStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isTryStatement: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method isTupleTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isTupleTypeAnnotation: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isTypeAlias

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isTypeAlias: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isTypeAnnotation: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isTypeCastExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isTypeCastExpression: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isTypeofTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isTypeofTypeAnnotation: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isTypeParameterDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isTypeParameterDeclaration: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isTypeParameterInstantiation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isTypeParameterInstantiation: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isUnaryExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isUnaryExpression: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method isUnaryLike

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isUnaryLike: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isUnionTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isUnionTypeAnnotation: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isUpdateExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isUpdateExpression: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isUser

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isUser: (opts?: object) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isUserWhitespacable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isUserWhitespacable: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isVar

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isVar: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isVariableDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isVariableDeclaration: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isVariableDeclarator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isVariableDeclarator: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method isVoidTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isVoidTypeAnnotation: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isWhile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isWhile: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isWhileStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isWhileStatement: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isWithStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isWithStatement: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isYieldExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isYieldExpression: (opts?: object) => this is NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method matchesPattern

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  matchesPattern: (pattern: string, allowPartial?: boolean) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Match the current node if it matches the provided pattern.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For example, given the match React.createClass it would match the parsed nodes of React.createClass and React["createClass"].

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method popContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  popContext: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method pushContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    pushContext: (context: TraversalContext) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method referencesImport

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      referencesImport: (moduleSource: string, importName: string) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Check if the currently assigned path references the importName of moduleSource.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method remove

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      remove: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method replaceExpressionWithStatements

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        replaceExpressionWithStatements: (nodes: Node[]) => any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • This method takes an array of statements nodes and then explodes it into expressions. This method retains completion records which is extremely important to retain original semantics.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method replaceInline

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        replaceInline: (nodes: Node | Node[]) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method replaceWith

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          replaceWith: (replacement: Node | NodePath) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Replace the current node with another.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method replaceWithMultiple

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          replaceWithMultiple: (nodes: Node[]) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Replace a node with an array of multiple. This method performs the following steps:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            - Inherit the comments of first provided node with that of the current node. - Insert the provided nodes after the current node. - Remove the current node.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method replaceWithSourceString

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          replaceWithSourceString: (replacement: any) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Parse a string as an expression and replace the current node with the result.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            NOTE: This is typically not a good idea to use. Building source strings when transforming ASTs is an antipattern and SHOULD NOT be encouraged. Even if it's easier to use, your transforms will be extremely brittle.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method set

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          set: (key: string, node: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method setContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            setContext: (context: TraversalContext) => NodePath<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method setData

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              setData: (key: string, val: any) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method setScope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                setScope: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method shareCommentsWithSiblings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  shareCommentsWithSiblings: () => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Share comments amongst siblings.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method skip

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  skip: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method skipKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    skipKey: (key: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method stop

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      stop: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method traverse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        traverse: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        <T>(visitor: Visitor<T>, state: T): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (visitor: Visitor<any>): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method updateSiblingKeys

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          updateSiblingKeys: (fromIndex: number, incrementBy: number) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Update all sibling node paths after fromIndex by incrementBy.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method visit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          visit: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method willIMaybeExecuteBefore

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            willIMaybeExecuteBefore: (path: NodePath) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Check if the current path will maybe execute before another path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class Scope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class Scope {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              constructor(path: NodePath<any>, parentScope?: Scope);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property bindings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                bindings: { [name: string]: Binding };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property block

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  block: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property hub

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    hub: Hub;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property parent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      parent: Scope;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property parentBlock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        parentBlock: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          path: NodePath<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method addGlobal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            addGlobal: (node: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method bindingIdentifierEquals

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              bindingIdentifierEquals: (name: string, node: any) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method buildUndefinedNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                buildUndefinedNode: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method checkBlockScopedCollisions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  checkBlockScopedCollisions: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  local: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  kind: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  name: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  id: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method dump

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    dump: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method generateDeclaredUidIdentifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      generateDeclaredUidIdentifier: (name?: string) => any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Generate a unique identifier and add it to the current scope.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method generateUid

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      generateUid: (name?: string) => string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Generate a unique _id1 binding.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method generateUidIdentifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      generateUidIdentifier: (name?: string) => any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Generate a unique identifier.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method generateUidIdentifierBasedOnNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      generateUidIdentifierBasedOnNode: (parent: any, defaultName?: string) => any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Generate a unique identifier based on a node.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getAllBindings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getAllBindings: (...kinds: string[]) => object;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Walks the scope tree and gathers **all** bindings.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getBinding

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getBinding: (name: string) => Binding | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method getBindingIdentifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        getBindingIdentifier: (name: string) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method getBlockParent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getBlockParent: () => Scope;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method getData

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            getData: (key: string) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method getFunctionParent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getFunctionParent: () => Scope;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method getOwnBinding

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                getOwnBinding: (name: string) => Binding | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method getOwnBindingIdentifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  getOwnBindingIdentifier: (name: string) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method getProgramParent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    getProgramParent: () => Scope;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method hasBinding

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      hasBinding: (name: string, noGlobals?: boolean) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method hasGlobal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        hasGlobal: (name: string) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method hasOwnBinding

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          hasOwnBinding: (name: string) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method hasReference

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            hasReference: (name: string) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method hasUid

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              hasUid: (name: string) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isPure

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isPure: (node: any, constantsOnly?: boolean) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isStatic

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isStatic: (node: any) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Determine whether evaluating the specific input node is a consequenceless reference. ie. evaluating it wont result in potentially arbitrary code from being ran. The following are whitelisted and determined not to cause side effects:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - this expressions - super expressions - Bound identifiers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method maybeGenerateMemoised

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  maybeGenerateMemoised: (node: any, dontPush?: boolean) => any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Possibly generate a memoised identifier if it is not static and has consequences.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method moveBindingTo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  moveBindingTo: (name: string, scope: Scope) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Move a binding of name to another scope.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method parentHasBinding

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  parentHasBinding: (name: string, noGlobals?: boolean) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method push

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    push: (opts: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method registerBinding

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      registerBinding: (kind: string, path: NodePath, bindingPath?: NodePath) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method registerConstantViolation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        registerConstantViolation: (path: NodePath) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method registerDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          registerDeclaration: (path: NodePath) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method removeBinding

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            removeBinding: (name: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method removeData

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              removeData: (key: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method removeOwnBinding

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                removeOwnBinding: (name: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method rename

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  rename: (oldName: string, newName?: string, block?: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method setData

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    setData: (key: string, val: any) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method toArray

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      toArray: (node: any, i?: number) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method traverse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        traverse: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        <S>(node: Node | Node[], opts: TraverseOptions<S>, state: S): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (node: any, opts?: TraverseOptions<any>, state?: any): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Traverse node with current scope and path.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Interfaces

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface TraversalContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface TraversalContext {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property opts

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          opts: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property parentPath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            parentPath: NodePath;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property scope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              scope: Scope;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property state

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                state: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface TraverseOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface TraverseOptions<S = Node> extends Visitor<S> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property noScope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    noScope?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property scope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      scope?: Scope;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface VisitNodeObject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface VisitNodeObject<T> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method enter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          enter: (path: NodePath<T>, state: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method exit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            exit: (path: NodePath<T>, state: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface Visitor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface Visitor<S = Node> extends VisitNodeObject<Node> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property AnyTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                AnyTypeAnnotation?: VisitNode<S, t.AnyTypeAnnotation>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property ArrayExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ArrayExpression?: VisitNode<S, t.ArrayExpression>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property ArrayPattern

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ArrayPattern?: VisitNode<S, t.ArrayPattern>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property ArrayTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ArrayTypeAnnotation?: VisitNode<S, t.ArrayTypeAnnotation>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property ArrowFunctionExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ArrowFunctionExpression?: VisitNode<S, t.ArrowFunctionExpression>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property AssignmentExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          AssignmentExpression?: VisitNode<S, t.AssignmentExpression>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property AssignmentPattern

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            AssignmentPattern?: VisitNode<S, t.AssignmentPattern>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property AwaitExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              AwaitExpression?: VisitNode<S, t.AwaitExpression>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property Binary

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Binary?: VisitNode<S, t.Binary>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property BinaryExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  BinaryExpression?: VisitNode<S, t.BinaryExpression>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property BindExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    BindExpression?: VisitNode<S, t.BindExpression>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property Block

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Block?: VisitNode<S, t.Block>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property BlockParent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        BlockParent?: VisitNode<S, t.BlockParent>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property BlockStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          BlockStatement?: VisitNode<S, t.BlockStatement>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property BooleanLiteral