• Version 6.25.7
  • Published
  • 52 kB
  • 1 dependency
  • MIT license


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


TypeScript definitions for babel-traverse





Type Aliases


function traverse

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


    class Binding

    class Binding {}


      constructor(opts: {
      existing: Binding;
      identifier: t.Identifier;
      scope: Scope;
      path: NodePath;
      kind: 'var' | 'let' | 'const';

        property constant

        constant: boolean;

          property constantViolations

          constantViolations: NodePath<t.Node>[];

            property identifier

            identifier: t.Identifier;

              property kind

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

                property path

                path: NodePath<t.Node>;

                  property referenced

                  referenced: boolean;

                    property referencePaths

                    referencePaths: NodePath<t.Node>[];

                      property references

                      references: number;

                        property scope

                        scope: Scope;

                          class Hub

                          class Hub {}


                            constructor(file: any, options: any);

                              property file

                              file: any;

                                property options

                                options: any;

                                  class NodePath

                                  class NodePath<T = Node> {}


                                    constructor(hub: Hub, parent: t.Node);

                                      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: t.Node;

                                                            property parentKey

                                                            parentKey: string;

                                                              property parentPath

                                                              parentPath: NodePath<t.Node>;

                                                                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: t.Node) => 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.


                                                                                                                                                                                                                                                                                                                                                                                                                                                      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<t.Node>
                                                                                                                                                                                                                                                                                                                                                                                                                                                      | NodePath<t.Node>[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                        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: t.Node, 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 getNextSibling

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  getNextSibling: () => NodePath;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method getOpposite

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    getOpposite: () => NodePath;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getOuterBindingIdentifiers

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method getPathLocation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        getPathLocation: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method getPrevSibling

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getPrevSibling: () => NodePath;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            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: () => t.FlowTypeAnnotation;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • 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<t.AnyTypeAnnotation>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isArrayExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isArrayExpression: (opts?: object) => this is NodePath<t.ArrayExpression>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isArrayPattern

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isArrayPattern: (opts?: object) => this is NodePath<t.ArrayPattern>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method isArrayTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isArrayTypeAnnotation: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => this is NodePath<t.ArrayTypeAnnotation>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isArrowFunctionExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isArrowFunctionExpression: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => this is NodePath<t.ArrowFunctionExpression>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isAssignmentExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isAssignmentExpression: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => this is NodePath<t.AssignmentExpression>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isAssignmentPattern

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isAssignmentPattern: (opts?: object) => this is NodePath<t.AssignmentPattern>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isAwaitExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isAwaitExpression: (opts?: object) => this is NodePath<t.AwaitExpression>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isBaseType

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isBinary

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isBinary: (opts?: object) => this is NodePath<t.Binary>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isBinaryExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isBinaryExpression: (opts?: object) => this is NodePath<t.BinaryExpression>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method isBindExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isBindExpression: (opts?: object) => this is NodePath<t.BindExpression>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isBindingIdentifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isBindingIdentifier: (opts?: object) => this is NodePath<t.Identifier>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isBlacklisted

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isBlacklisted: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isBlock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isBlock: (opts?: object) => this is NodePath<t.Block>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isBlockParent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isBlockParent: (opts?: object) => this is NodePath<t.BlockParent>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isBlockScoped

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isBlockStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isBlockStatement: (opts?: object) => this is NodePath<t.BlockStatement>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isBooleanLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isBooleanLiteral: (opts?: object) => this is NodePath<t.BooleanLiteral>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method isBooleanLiteralTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isBooleanLiteralTypeAnnotation: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => this is NodePath<t.BooleanLiteralTypeAnnotation>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isBooleanTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isBooleanTypeAnnotation: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => this is NodePath<t.BooleanTypeAnnotation>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isBreakStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isBreakStatement: (opts?: object) => this is NodePath<t.BreakStatement>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isCallExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isCallExpression: (opts?: object) => this is NodePath<t.CallExpression>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isCatchClause

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isCatchClause: (opts?: object) => this is NodePath<t.CatchClause>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isClass: (opts?: object) => this is NodePath<t.Class>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isClassBody

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isClassBody: (opts?: object) => this is NodePath<t.ClassBody>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isClassDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isClassDeclaration: (opts?: object) => this is NodePath<t.ClassDeclaration>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method isClassExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isClassExpression: (opts?: object) => this is NodePath<t.ClassExpression>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isClassImplements

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isClassImplements: (opts?: object) => this is NodePath<t.ClassImplements>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isClassMethod

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isClassMethod: (opts?: object) => this is NodePath<t.ClassMethod>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isClassProperty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isClassProperty: (opts?: object) => this is NodePath<t.ClassProperty>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isCompletionRecord

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isCompletionStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isCompletionStatement: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => this is NodePath<t.CompletionStatement>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isConditional

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isConditional: (opts?: object) => this is NodePath<t.Conditional>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isConditionalExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isConditionalExpression: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => this is NodePath<t.ConditionalExpression>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isContinueStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isContinueStatement: (opts?: object) => this is NodePath<t.ContinueStatement>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method isDebuggerStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isDebuggerStatement: (opts?: object) => this is NodePath<t.DebuggerStatement>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isDeclaration: (opts?: object) => this is NodePath<t.Declaration>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isDeclareClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isDeclareClass: (opts?: object) => this is NodePath<t.DeclareClass>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isDeclareFunction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isDeclareFunction: (opts?: object) => this is NodePath<t.DeclareFunction>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isDeclareInterface

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isDeclareInterface: (opts?: object) => this is NodePath<t.DeclareInterface>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isDeclareModule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isDeclareModule: (opts?: object) => this is NodePath<t.DeclareModule>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isDeclareTypeAlias

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isDeclareTypeAlias: (opts?: object) => this is NodePath<t.DeclareTypeAlias>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isDeclareVariable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isDeclareVariable: (opts?: object) => this is NodePath<t.DeclareVariable>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method isDecorator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isDecorator: (opts?: object) => this is NodePath<t.Decorator>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isDirective

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isDirective: (opts?: object) => this is NodePath<t.Directive>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isDirectiveLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isDirectiveLiteral: (opts?: object) => this is NodePath<t.DirectiveLiteral>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isDoExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isDoExpression: (opts?: object) => this is NodePath<t.DoExpression>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isDoWhileStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isDoWhileStatement: (opts?: object) => this is NodePath<t.DoWhileStatement>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isEmptyStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isEmptyStatement: (opts?: object) => this is NodePath<t.EmptyStatement>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isExistentialTypeParam

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isExistentialTypeParam: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => this is NodePath<t.ExistentialTypeParam>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isExportAllDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isExportAllDeclaration: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => this is NodePath<t.ExportAllDeclaration>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method isExportDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isExportDeclaration: (opts?: object) => this is NodePath<t.ExportDeclaration>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isExportDefaultDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isExportDefaultDeclaration: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => this is NodePath<t.ExportDefaultDeclaration>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isExportDefaultSpecifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isExportDefaultSpecifier: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => this is NodePath<t.ExportDefaultSpecifier>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isExportNamedDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isExportNamedDeclaration: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => this is NodePath<t.ExportNamedDeclaration>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isExportNamespaceSpecifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isExportNamespaceSpecifier: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => this is NodePath<t.ExportNamespaceSpecifier>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isExportSpecifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isExportSpecifier: (opts?: object) => this is NodePath<t.ExportSpecifier>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isExpression: (opts?: object) => this is NodePath<t.Expression>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isExpressionStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isExpressionStatement: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => this is NodePath<t.ExpressionStatement>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method isExpressionWrapper

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isExpressionWrapper: (opts?: object) => this is NodePath<t.ExpressionWrapper>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isFile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isFile: (opts?: object) => this is NodePath<t.File>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isFlow

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isFlow: (opts?: object) => this is NodePath<t.Flow>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isFlowBaseAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isFlowBaseAnnotation: (opts?: object) => this is NodePath<t.FlowBaseAnnotation>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isFlowDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isFlowDeclaration: (opts?: object) => this is NodePath<t.FlowDeclaration>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isFor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isFor: (opts?: object) => this is NodePath<t.For>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isForInStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isForInStatement: (opts?: object) => this is NodePath<t.ForInStatement>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isForOfStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isForOfStatement: (opts?: object) => this is NodePath<t.ForOfStatement>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method isForStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isForStatement: (opts?: object) => this is NodePath<t.ForStatement>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isForXStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isForXStatement: (opts?: object) => this is NodePath<t.ForXStatement>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isFunction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isFunction: (opts?: object) => this is NodePath<t.Function>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isFunctionDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isFunctionDeclaration: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => this is NodePath<t.FunctionDeclaration>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isFunctionExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isFunctionExpression: (opts?: object) => this is NodePath<t.FunctionExpression>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isFunctionParent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isFunctionParent: (opts?: object) => this is NodePath<t.FunctionParent>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isFunctionTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isFunctionTypeAnnotation: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => this is NodePath<t.FunctionTypeAnnotation>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isFunctionTypeParam

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isFunctionTypeParam: (opts?: object) => this is NodePath<t.FunctionTypeParam>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method isGenerated

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isGenericType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isGenericType: (genericName: string) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isGenericTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isGenericTypeAnnotation: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => this is NodePath<t.GenericTypeAnnotation>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isIdentifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isIdentifier: (opts?: object) => this is NodePath<t.Identifier>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isIfStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isIfStatement: (opts?: object) => this is NodePath<t.IfStatement>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isImmutable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isImmutable: (opts?: object) => this is NodePath<t.Immutable>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isImportDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isImportDeclaration: (opts?: object) => this is NodePath<t.ImportDeclaration>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isImportDefaultSpecifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isImportDefaultSpecifier: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => this is NodePath<t.ImportDefaultSpecifier>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method isImportNamespaceSpecifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isImportNamespaceSpecifier: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => this is NodePath<t.ImportNamespaceSpecifier>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isImportSpecifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isImportSpecifier: (opts?: object) => this is NodePath<t.ImportSpecifier>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isInterfaceDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isInterfaceDeclaration: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => this is NodePath<t.InterfaceDeclaration>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isInterfaceExtends

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isInterfaceExtends: (opts?: object) => this is NodePath<t.InterfaceExtends>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isIntersectionTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isIntersectionTypeAnnotation: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => this is NodePath<t.IntersectionTypeAnnotation>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isJSX

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isJSX: (opts?: object) => this is NodePath<t.JSX>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isJSXAttribute

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isJSXAttribute: (opts?: object) => this is NodePath<t.JSXAttribute>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isJSXClosingElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isJSXClosingElement: (opts?: object) => this is NodePath<t.JSXClosingElement>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method isJSXElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isJSXElement: (opts?: object) => this is NodePath<t.JSXElement>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isJSXEmptyExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isJSXEmptyExpression: (opts?: object) => this is NodePath<t.JSXEmptyExpression>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isJSXExpressionContainer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isJSXExpressionContainer: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => this is NodePath<t.JSXExpressionContainer>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isJSXIdentifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isJSXIdentifier: (opts?: object) => this is NodePath<t.JSXIdentifier>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isJSXMemberExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isJSXMemberExpression: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => this is NodePath<t.JSXMemberExpression>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isJSXNamespacedName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isJSXNamespacedName: (opts?: object) => this is NodePath<t.JSXNamespacedName>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isJSXOpeningElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isJSXOpeningElement: (opts?: object) => this is NodePath<t.JSXOpeningElement>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isJSXSpreadAttribute

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isJSXSpreadAttribute: (opts?: object) => this is NodePath<t.JSXSpreadAttribute>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method isJSXText

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isJSXText: (opts?: object) => this is NodePath<t.JSXText>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isLabeledStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isLabeledStatement: (opts?: object) => this is NodePath<t.LabeledStatement>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isLiteral: (opts?: object) => this is NodePath<t.Literal>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isLogicalExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isLogicalExpression: (opts?: object) => this is NodePath<t.LogicalExpression>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isLoop

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isLoop: (opts?: object) => this is NodePath<t.Loop>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isLVal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isLVal: (opts?: object) => this is NodePath<t.LVal>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isMemberExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isMemberExpression: (opts?: object) => this is NodePath<t.MemberExpression>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isMetaProperty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isMetaProperty: (opts?: object) => this is NodePath<t.MetaProperty>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method isMethod

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isMethod: (opts?: object) => this is NodePath<t.Method>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isMixedTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isMixedTypeAnnotation: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => this is NodePath<t.MixedTypeAnnotation>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isModuleDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isModuleDeclaration: (opts?: object) => this is NodePath<t.ModuleDeclaration>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isModuleSpecifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isModuleSpecifier: (opts?: object) => this is NodePath<t.ModuleSpecifier>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isNewExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isNewExpression: (opts?: object) => this is NodePath<t.NewExpression>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  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<t.Noop>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isnt

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isNullableTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isNullableTypeAnnotation: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => this is NodePath<t.NullableTypeAnnotation>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isNullLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isNullLiteral: (opts?: object) => this is NodePath<t.NullLiteral>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method isNullLiteralTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isNullLiteralTypeAnnotation: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => this is NodePath<t.NullLiteralTypeAnnotation>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isNumberLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isNumberLiteral: (opts?: object) => this is NodePath<t.NumericLiteral>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isNumberTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isNumberTypeAnnotation: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => this is NodePath<t.NumberTypeAnnotation>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isNumericLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isNumericLiteral: (opts?: object) => this is NodePath<t.NumericLiteral>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isNumericLiteralTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isNumericLiteralTypeAnnotation: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => this is NodePath<t.NumericLiteralTypeAnnotation>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isObjectExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isObjectExpression: (opts?: object) => this is NodePath<t.ObjectExpression>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isObjectMember

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isObjectMember: (opts?: object) => this is NodePath<t.ObjectMember>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isObjectMethod

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isObjectMethod: (opts?: object) => this is NodePath<t.ObjectMethod>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method isObjectPattern

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isObjectPattern: (opts?: object) => this is NodePath<t.ObjectPattern>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isObjectProperty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isObjectProperty: (opts?: object) => this is NodePath<t.ObjectProperty>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isObjectTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isObjectTypeAnnotation: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => this is NodePath<t.ObjectTypeAnnotation>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isObjectTypeCallProperty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isObjectTypeCallProperty: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => this is NodePath<t.ObjectTypeCallProperty>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isObjectTypeIndexer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isObjectTypeIndexer: (opts?: object) => this is NodePath<t.ObjectTypeIndexer>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isObjectTypeProperty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isObjectTypeProperty: (opts?: object) => this is NodePath<t.ObjectTypeProperty>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isParenthesizedExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isParenthesizedExpression: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => this is NodePath<t.ParenthesizedExpression>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isPattern

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isPattern: (opts?: object) => this is NodePath<t.Pattern>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method isProgram

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isProgram: (opts?: object) => this is NodePath<t.Program>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isProperty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isProperty: (opts?: object) => this is NodePath<t.Property>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isPure

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isPureish

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isPureish: (opts?: object) => this is NodePath<t.Pureish>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isQualifiedTypeIdentifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isQualifiedTypeIdentifier: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => this is NodePath<t.QualifiedTypeIdentifier>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isReferenced

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isReferencedIdentifier

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isReferencedMemberExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isReferencedMemberExpression: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => this is NodePath<t.MemberExpression>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method isRegexLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isRegexLiteral: (opts?: object) => this is NodePath<t.RegExpLiteral>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isRegExpLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isRegExpLiteral: (opts?: object) => this is NodePath<t.RegExpLiteral>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isRestElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isRestElement: (opts?: object) => this is NodePath<t.RestElement>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isRestProperty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isRestProperty: (opts?: object) => this is NodePath<t.RestProperty>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isReturnStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isReturnStatement: (opts?: object) => this is NodePath<t.ReturnStatement>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isScopable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isScopable: (opts?: object) => this is NodePath<t.Scopable>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isScope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isScope: (opts?: object) => this is NodePath<t.Scopable>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isSequenceExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isSequenceExpression: (opts?: object) => this is NodePath<t.SequenceExpression>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method isSpreadElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isSpreadElement: (opts?: object) => this is NodePath<t.SpreadElement>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isSpreadProperty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isSpreadProperty: (opts?: object) => this is NodePath<t.SpreadProperty>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isStatement: (opts?: object) => this is NodePath<t.Statement>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              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<t.StringLiteral>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isStringLiteralTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isStringLiteralTypeAnnotation: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => this is NodePath<t.StringLiteralTypeAnnotation>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isStringTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isStringTypeAnnotation: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => this is NodePath<t.StringTypeAnnotation>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isSuper

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isSuper: (opts?: object) => this is NodePath<t.Super>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method isSwitchCase

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isSwitchCase: (opts?: object) => this is NodePath<t.SwitchCase>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isSwitchStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isSwitchStatement: (opts?: object) => this is NodePath<t.SwitchStatement>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isTaggedTemplateExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isTaggedTemplateExpression: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => this is NodePath<t.TaggedTemplateExpression>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isTemplateElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isTemplateElement: (opts?: object) => this is NodePath<t.TemplateElement>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isTemplateLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isTemplateLiteral: (opts?: object) => this is NodePath<t.TemplateLiteral>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isTerminatorless

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isTerminatorless: (opts?: object) => this is NodePath<t.Terminatorless>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isThisExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isThisExpression: (opts?: object) => this is NodePath<t.ThisExpression>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isThisTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isThisTypeAnnotation: (opts?: object) => this is NodePath<t.ThisTypeAnnotation>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method isThrowStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isThrowStatement: (opts?: object) => this is NodePath<t.ThrowStatement>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isTryStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isTryStatement: (opts?: object) => this is NodePath<t.TryStatement>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isTupleTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isTupleTypeAnnotation: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => this is NodePath<t.TupleTypeAnnotation>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isTypeAlias

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isTypeAlias: (opts?: object) => this is NodePath<t.TypeAlias>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isTypeAnnotation: (opts?: object) => this is NodePath<t.TypeAnnotation>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isTypeCastExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isTypeCastExpression: (opts?: object) => this is NodePath<t.TypeCastExpression>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isTypeofTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isTypeofTypeAnnotation: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => this is NodePath<t.TypeofTypeAnnotation>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isTypeParameterDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isTypeParameterDeclaration: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => this is NodePath<t.TypeParameterDeclaration>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method isTypeParameterInstantiation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isTypeParameterInstantiation: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => this is NodePath<t.TypeParameterInstantiation>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isUnaryExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isUnaryExpression: (opts?: object) => this is NodePath<t.UnaryExpression>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isUnaryLike

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isUnaryLike: (opts?: object) => this is NodePath<t.UnaryLike>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isUnionTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isUnionTypeAnnotation: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => this is NodePath<t.UnionTypeAnnotation>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isUpdateExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isUpdateExpression: (opts?: object) => this is NodePath<t.UpdateExpression>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isUser

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isUserWhitespacable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isUserWhitespacable: (opts?: object) => this is NodePath<t.UserWhitespacable>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isVar

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isVar: (opts?: object) => this is NodePath<t.VariableDeclaration>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method isVariableDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isVariableDeclaration: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => this is NodePath<t.VariableDeclaration>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isVariableDeclarator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isVariableDeclarator: (opts?: object) => this is NodePath<t.VariableDeclarator>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isVoidTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isVoidTypeAnnotation: (opts?: object) => this is NodePath<t.VoidTypeAnnotation>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isWhile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isWhile: (opts?: object) => this is NodePath<t.While>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isWhileStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isWhileStatement: (opts?: object) => this is NodePath<t.WhileStatement>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isWithStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isWithStatement: (opts?: object) => this is NodePath<t.WithStatement>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isYieldExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isYieldExpression: (opts?: object) => this is NodePath<t.YieldExpression>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      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[]) => t.Node;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • 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: t.Node) => 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<t.Node>): 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(path: NodePath<t.Node>, parentScope?: Scope);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property bindings

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property block

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      block: t.Node;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property hub

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        hub: Hub;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property parent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          parent: Scope;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property parentBlock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            parentBlock: t.Node;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              path: NodePath<t.Node>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method addGlobal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                addGlobal: (node: t.Node) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method bindingIdentifierEquals

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  bindingIdentifierEquals: (name: string, node: t.Node) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method buildUndefinedNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    buildUndefinedNode: () => t.Node;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method checkBlockScopedCollisions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      checkBlockScopedCollisions: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      local: t.Node,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      kind: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      name: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      id: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method dump

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        dump: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method generateDeclaredUidIdentifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          generateDeclaredUidIdentifier: (name?: string) => t.Identifier;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • 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) => t.Identifier;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Generate a unique identifier.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method generateUidIdentifierBasedOnNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          generateUidIdentifierBasedOnNode: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          parent: t.Node,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          defaultName?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => t.Identifier;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • 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) => t.Identifier;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              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) => t.Identifier;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        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: t.Node, constantsOnly?: boolean) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isStatic

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isStatic: (node: t.Node) => 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: t.Node, dontPush?: boolean) => t.Identifier;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • 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?: t.Node) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method setData

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method toArray

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          toArray: (node: t.Node, i?: number) => t.Node;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method traverse

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


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            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> {}