@types/babel__traverse

  • Version 7.20.6
  • Published
  • 84.1 kB
  • 1 dependency
  • MIT license

Install

npm i @types/babel__traverse
yarn add @types/babel__traverse
pnpm add @types/babel__traverse

Overview

TypeScript definitions for @babel/traverse

Index

Variables

Classes

Interfaces

Type Aliases

Namespaces

Variables

variable traverse

const traverse: {
<S>(
parent: Node,
opts: TraverseOptions<S>,
scope: Scope | undefined,
state: S,
parentPath?: NodePath
): void;
(
parent: Node,
opts?: TraverseOptions,
scope?: Scope,
state?: any,
parentPath?: NodePath
): void;
visitors: typeof visitors;
verify: typeof visitors.verify;
explode: typeof visitors.explode;
cheap: (node: Node, enter: (node: Node) => void) => void;
node: (
node: Node,
opts: TraverseOptions,
scope?: Scope,
state?: any,
path?: NodePath,
skipKeys?: Record<string, boolean>
) => void;
clearNode: (node: Node, opts?: RemovePropertiesOptions) => void;
removeProperties: (tree: Node, opts?: RemovePropertiesOptions) => Node;
hasType: (tree: Node, type: Node, denylistTypes?: string[]) => boolean;
cache: typeof cache;
};

    Classes

    class Binding

    class Binding {}
    • This class is responsible for a binding inside of a scope.

      It tracks the following:

      * Node path. * Amount of times referenced by other nodes. * Paths to nodes that reassign or modify this binding. * The kind of binding. (Is it a parameter, declaration etc)

    constructor

    constructor(opts: {
    identifier: t.Identifier;
    scope: Scope;
    path: NodePath;
    kind: BindingKind;
    });

      property constant

      constant: boolean;

        property constantViolations

        constantViolations: NodePath<Node>[];

          property hasDeoptedValue

          hasDeoptedValue: boolean;

            property hasValue

            hasValue: boolean;

              property identifier

              identifier: t.Identifier;

                property kind

                kind: BindingKind;

                  property path

                  path: NodePath<Node>;

                    property referenced

                    referenced: boolean;

                      property referencePaths

                      referencePaths: NodePath<Node>[];

                        property references

                        references: number;

                          property scope

                          scope: Scope;

                            property value

                            value: any;

                              method clearValue

                              clearValue: () => void;

                                method deopValue

                                deopValue: () => void;

                                  method dereference

                                  dereference: () => void;
                                  • Decrement the amount of references to this binding.

                                  method reassign

                                  reassign: (path: NodePath) => void;
                                  • Register a constant violation with the provided path.

                                  method reference

                                  reference: (path: NodePath) => void;
                                  • Increment the amount of references to this binding.

                                  method setValue

                                  setValue: (value: any) => void;

                                    class Hub

                                    class Hub implements HubInterface {}

                                      constructor

                                      constructor();

                                        method addHelper

                                        addHelper: (name: string) => any;

                                          method buildError

                                          buildError: (node: Node, msg: string, Error?: ErrorConstructor) => Error;

                                            method getCode

                                            getCode: () => string | undefined;

                                              method getScope

                                              getScope: () => Scope | undefined;

                                                class NodePath

                                                class NodePath<T = Node> {}

                                                  constructor

                                                  constructor(hub: HubInterface, parent: Node);

                                                    property container

                                                    container: any;

                                                      property context

                                                      context: TraversalContext<unknown>;

                                                        property contexts

                                                        contexts: TraversalContext<unknown>[];

                                                          property data

                                                          data: Record<string | symbol, unknown>;

                                                            property hub

                                                            hub: Hub;

                                                              property inList

                                                              inList: boolean;

                                                                property key

                                                                key: string | number;

                                                                  property listKey

                                                                  listKey: string;

                                                                    property node

                                                                    node: {};

                                                                      property opts

                                                                      opts: any;

                                                                        property parent

                                                                        parent: Node;

                                                                          property parentKey

                                                                          parentKey: string;

                                                                            property parentPath

                                                                            parentPath: NodePath<Node>;

                                                                              property removed

                                                                              removed: boolean;

                                                                                property scope

                                                                                scope: Scope;

                                                                                  property shouldSkip

                                                                                  shouldSkip: boolean;

                                                                                    property shouldStop

                                                                                    shouldStop: boolean;

                                                                                      property skipKeys

                                                                                      skipKeys: Record<string, boolean>;

                                                                                        property state

                                                                                        state: any;

                                                                                          property type

                                                                                          type: {};

                                                                                            property typeAnnotation

                                                                                            typeAnnotation: {};

                                                                                              method addComment

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

                                                                                                method addComments

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

                                                                                                method arrowFunctionToExpression

                                                                                                arrowFunctionToExpression: ({
                                                                                                allowInsertArrow,
                                                                                                allowInsertArrowWithRest,
                                                                                                specCompliant,
                                                                                                noNewArrows,
                                                                                                }?: {
                                                                                                allowInsertArrow?: boolean;
                                                                                                allowInsertArrowWithRest?: boolean;
                                                                                                specCompliant?: boolean;
                                                                                                noNewArrows?: boolean;
                                                                                                }) => NodePath<
                                                                                                Exclude<t.Function, t.Method | t.ArrowFunctionExpression> | t.CallExpression
                                                                                                >;
                                                                                                • Convert a given arrow function into a normal ES5 function expression.

                                                                                                method arrowFunctionToShadowed

                                                                                                arrowFunctionToShadowed: () => void;
                                                                                                • Deprecated

                                                                                                  Use arrowFunctionToExpression

                                                                                                method assertAccessor

                                                                                                assertAccessor: (opts?: object) => asserts this is NodePath<t.Accessor>;

                                                                                                  method assertAnyTypeAnnotation

                                                                                                  assertAnyTypeAnnotation: (
                                                                                                  opts?: object
                                                                                                  ) => asserts this is NodePath<t.AnyTypeAnnotation>;

                                                                                                    method assertArgumentPlaceholder

                                                                                                    assertArgumentPlaceholder: (
                                                                                                    opts?: object
                                                                                                    ) => asserts this is NodePath<t.ArgumentPlaceholder>;

                                                                                                      method assertArrayExpression

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

                                                                                                        method assertArrayPattern

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

                                                                                                          method assertArrayTypeAnnotation

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

                                                                                                            method assertArrowFunctionExpression

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

                                                                                                              method assertAssignmentExpression

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

                                                                                                                method assertAssignmentPattern

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

                                                                                                                  method assertAwaitExpression

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

                                                                                                                    method assertBigIntLiteral

                                                                                                                    assertBigIntLiteral: (
                                                                                                                    opts?: object
                                                                                                                    ) => asserts this is NodePath<t.BigIntLiteral>;

                                                                                                                      method assertBinary

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

                                                                                                                        method assertBinaryExpression

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

                                                                                                                          method assertBindExpression

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

                                                                                                                            method assertBlock

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

                                                                                                                              method assertBlockParent

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

                                                                                                                                method assertBlockStatement

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

                                                                                                                                  method assertBooleanLiteral

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

                                                                                                                                    method assertBooleanLiteralTypeAnnotation

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

                                                                                                                                      method assertBooleanTypeAnnotation

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

                                                                                                                                        method assertBreakStatement

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

                                                                                                                                          method assertCallExpression

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

                                                                                                                                            method assertCatchClause

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

                                                                                                                                              method assertClass

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

                                                                                                                                                method assertClassAccessorProperty

                                                                                                                                                assertClassAccessorProperty: (
                                                                                                                                                opts?: object
                                                                                                                                                ) => asserts this is NodePath<t.ClassAccessorProperty>;

                                                                                                                                                  method assertClassBody

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

                                                                                                                                                    method assertClassDeclaration

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

                                                                                                                                                      method assertClassExpression

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

                                                                                                                                                        method assertClassImplements

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

                                                                                                                                                          method assertClassMethod

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

                                                                                                                                                            method assertClassPrivateMethod

                                                                                                                                                            assertClassPrivateMethod: (
                                                                                                                                                            opts?: object
                                                                                                                                                            ) => asserts this is NodePath<t.ClassPrivateMethod>;

                                                                                                                                                              method assertClassPrivateProperty

                                                                                                                                                              assertClassPrivateProperty: (
                                                                                                                                                              opts?: object
                                                                                                                                                              ) => asserts this is NodePath<t.ClassPrivateProperty>;

                                                                                                                                                                method assertClassProperty

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

                                                                                                                                                                  method assertCompletionStatement

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

                                                                                                                                                                    method assertConditional

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

                                                                                                                                                                      method assertConditionalExpression

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

                                                                                                                                                                        method assertContinueStatement

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

                                                                                                                                                                          method assertDebuggerStatement

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

                                                                                                                                                                            method assertDecimalLiteral

                                                                                                                                                                            assertDecimalLiteral: (
                                                                                                                                                                            opts?: object
                                                                                                                                                                            ) => asserts this is NodePath<t.DecimalLiteral>;

                                                                                                                                                                              method assertDeclaration

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

                                                                                                                                                                                method assertDeclareClass

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

                                                                                                                                                                                  method assertDeclaredPredicate

                                                                                                                                                                                  assertDeclaredPredicate: (
                                                                                                                                                                                  opts?: object
                                                                                                                                                                                  ) => asserts this is NodePath<t.DeclaredPredicate>;

                                                                                                                                                                                    method assertDeclareExportAllDeclaration

                                                                                                                                                                                    assertDeclareExportAllDeclaration: (
                                                                                                                                                                                    opts?: object
                                                                                                                                                                                    ) => asserts this is NodePath<t.DeclareExportAllDeclaration>;

                                                                                                                                                                                      method assertDeclareExportDeclaration

                                                                                                                                                                                      assertDeclareExportDeclaration: (
                                                                                                                                                                                      opts?: object
                                                                                                                                                                                      ) => asserts this is NodePath<t.DeclareExportDeclaration>;

                                                                                                                                                                                        method assertDeclareFunction

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

                                                                                                                                                                                          method assertDeclareInterface

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

                                                                                                                                                                                            method assertDeclareModule

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

                                                                                                                                                                                              method assertDeclareModuleExports

                                                                                                                                                                                              assertDeclareModuleExports: (
                                                                                                                                                                                              opts?: object
                                                                                                                                                                                              ) => asserts this is NodePath<t.DeclareModuleExports>;

                                                                                                                                                                                                method assertDeclareOpaqueType

                                                                                                                                                                                                assertDeclareOpaqueType: (
                                                                                                                                                                                                opts?: object
                                                                                                                                                                                                ) => asserts this is NodePath<t.DeclareOpaqueType>;

                                                                                                                                                                                                  method assertDeclareTypeAlias

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

                                                                                                                                                                                                    method assertDeclareVariable

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

                                                                                                                                                                                                      method assertDecorator

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

                                                                                                                                                                                                        method assertDirective

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

                                                                                                                                                                                                          method assertDirectiveLiteral

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

                                                                                                                                                                                                            method assertDoExpression

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

                                                                                                                                                                                                              method assertDoWhileStatement

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

                                                                                                                                                                                                                method assertEmptyStatement

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

                                                                                                                                                                                                                  method assertEmptyTypeAnnotation

                                                                                                                                                                                                                  assertEmptyTypeAnnotation: (
                                                                                                                                                                                                                  opts?: object
                                                                                                                                                                                                                  ) => asserts this is NodePath<t.EmptyTypeAnnotation>;

                                                                                                                                                                                                                    method assertEnumBody

                                                                                                                                                                                                                    assertEnumBody: (opts?: object) => asserts this is NodePath<t.EnumBody>;

                                                                                                                                                                                                                      method assertEnumBooleanBody

                                                                                                                                                                                                                      assertEnumBooleanBody: (
                                                                                                                                                                                                                      opts?: object
                                                                                                                                                                                                                      ) => asserts this is NodePath<t.EnumBooleanBody>;

                                                                                                                                                                                                                        method assertEnumBooleanMember

                                                                                                                                                                                                                        assertEnumBooleanMember: (
                                                                                                                                                                                                                        opts?: object
                                                                                                                                                                                                                        ) => asserts this is NodePath<t.EnumBooleanMember>;

                                                                                                                                                                                                                          method assertEnumDeclaration

                                                                                                                                                                                                                          assertEnumDeclaration: (
                                                                                                                                                                                                                          opts?: object
                                                                                                                                                                                                                          ) => asserts this is NodePath<t.EnumDeclaration>;

                                                                                                                                                                                                                            method assertEnumDefaultedMember

                                                                                                                                                                                                                            assertEnumDefaultedMember: (
                                                                                                                                                                                                                            opts?: object
                                                                                                                                                                                                                            ) => asserts this is NodePath<t.EnumDefaultedMember>;

                                                                                                                                                                                                                              method assertEnumMember

                                                                                                                                                                                                                              assertEnumMember: (opts?: object) => asserts this is NodePath<t.EnumMember>;

                                                                                                                                                                                                                                method assertEnumNumberBody

                                                                                                                                                                                                                                assertEnumNumberBody: (
                                                                                                                                                                                                                                opts?: object
                                                                                                                                                                                                                                ) => asserts this is NodePath<t.EnumNumberBody>;

                                                                                                                                                                                                                                  method assertEnumNumberMember

                                                                                                                                                                                                                                  assertEnumNumberMember: (
                                                                                                                                                                                                                                  opts?: object
                                                                                                                                                                                                                                  ) => asserts this is NodePath<t.EnumNumberMember>;

                                                                                                                                                                                                                                    method assertEnumStringBody

                                                                                                                                                                                                                                    assertEnumStringBody: (
                                                                                                                                                                                                                                    opts?: object
                                                                                                                                                                                                                                    ) => asserts this is NodePath<t.EnumStringBody>;

                                                                                                                                                                                                                                      method assertEnumStringMember

                                                                                                                                                                                                                                      assertEnumStringMember: (
                                                                                                                                                                                                                                      opts?: object
                                                                                                                                                                                                                                      ) => asserts this is NodePath<t.EnumStringMember>;

                                                                                                                                                                                                                                        method assertEnumSymbolBody

                                                                                                                                                                                                                                        assertEnumSymbolBody: (
                                                                                                                                                                                                                                        opts?: object
                                                                                                                                                                                                                                        ) => asserts this is NodePath<t.EnumSymbolBody>;

                                                                                                                                                                                                                                          method assertExistsTypeAnnotation

                                                                                                                                                                                                                                          assertExistsTypeAnnotation: (
                                                                                                                                                                                                                                          opts?: object
                                                                                                                                                                                                                                          ) => asserts this is NodePath<t.ExistsTypeAnnotation>;

                                                                                                                                                                                                                                            method assertExportAllDeclaration

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

                                                                                                                                                                                                                                              method assertExportDeclaration

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

                                                                                                                                                                                                                                                method assertExportDefaultDeclaration

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

                                                                                                                                                                                                                                                  method assertExportDefaultSpecifier

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

                                                                                                                                                                                                                                                    method assertExportNamedDeclaration

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

                                                                                                                                                                                                                                                      method assertExportNamespaceSpecifier

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

                                                                                                                                                                                                                                                        method assertExportSpecifier

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

                                                                                                                                                                                                                                                          method assertExpression

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

                                                                                                                                                                                                                                                            method assertExpressionStatement

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

                                                                                                                                                                                                                                                              method assertExpressionWrapper

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

                                                                                                                                                                                                                                                                method assertFile

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

                                                                                                                                                                                                                                                                  method assertFlow

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

                                                                                                                                                                                                                                                                    method assertFlowBaseAnnotation

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

                                                                                                                                                                                                                                                                      method assertFlowDeclaration

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

                                                                                                                                                                                                                                                                        method assertFlowPredicate

                                                                                                                                                                                                                                                                        assertFlowPredicate: (
                                                                                                                                                                                                                                                                        opts?: object
                                                                                                                                                                                                                                                                        ) => asserts this is NodePath<t.FlowPredicate>;

                                                                                                                                                                                                                                                                          method assertFlowType

                                                                                                                                                                                                                                                                          assertFlowType: (opts?: object) => asserts this is NodePath<t.FlowType>;

                                                                                                                                                                                                                                                                            method assertFor

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

                                                                                                                                                                                                                                                                              method assertForInStatement

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

                                                                                                                                                                                                                                                                                method assertForOfStatement

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

                                                                                                                                                                                                                                                                                  method assertForStatement

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

                                                                                                                                                                                                                                                                                    method assertForXStatement

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

                                                                                                                                                                                                                                                                                      method assertFunction

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

                                                                                                                                                                                                                                                                                        method assertFunctionDeclaration

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

                                                                                                                                                                                                                                                                                          method assertFunctionExpression

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

                                                                                                                                                                                                                                                                                            method assertFunctionParent

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

                                                                                                                                                                                                                                                                                              method assertFunctionTypeAnnotation

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

                                                                                                                                                                                                                                                                                                method assertFunctionTypeParam

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

                                                                                                                                                                                                                                                                                                  method assertGenericTypeAnnotation

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

                                                                                                                                                                                                                                                                                                    method assertIdentifier

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

                                                                                                                                                                                                                                                                                                      method assertIfStatement

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

                                                                                                                                                                                                                                                                                                        method assertImmutable

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

                                                                                                                                                                                                                                                                                                          method assertImport

                                                                                                                                                                                                                                                                                                          assertImport: (opts?: object) => asserts this is NodePath<t.Import>;

                                                                                                                                                                                                                                                                                                            method assertImportAttribute

                                                                                                                                                                                                                                                                                                            assertImportAttribute: (
                                                                                                                                                                                                                                                                                                            opts?: object
                                                                                                                                                                                                                                                                                                            ) => asserts this is NodePath<t.ImportAttribute>;

                                                                                                                                                                                                                                                                                                              method assertImportDeclaration

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

                                                                                                                                                                                                                                                                                                                method assertImportDefaultSpecifier

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

                                                                                                                                                                                                                                                                                                                  method assertImportNamespaceSpecifier

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

                                                                                                                                                                                                                                                                                                                    method assertImportSpecifier

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

                                                                                                                                                                                                                                                                                                                      method assertIndexedAccessType

                                                                                                                                                                                                                                                                                                                      assertIndexedAccessType: (
                                                                                                                                                                                                                                                                                                                      opts?: object
                                                                                                                                                                                                                                                                                                                      ) => asserts this is NodePath<t.IndexedAccessType>;

                                                                                                                                                                                                                                                                                                                        method assertInferredPredicate

                                                                                                                                                                                                                                                                                                                        assertInferredPredicate: (
                                                                                                                                                                                                                                                                                                                        opts?: object
                                                                                                                                                                                                                                                                                                                        ) => asserts this is NodePath<t.InferredPredicate>;

                                                                                                                                                                                                                                                                                                                          method assertInterfaceDeclaration

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

                                                                                                                                                                                                                                                                                                                            method assertInterfaceExtends

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

                                                                                                                                                                                                                                                                                                                              method assertInterfaceTypeAnnotation

                                                                                                                                                                                                                                                                                                                              assertInterfaceTypeAnnotation: (
                                                                                                                                                                                                                                                                                                                              opts?: object
                                                                                                                                                                                                                                                                                                                              ) => asserts this is NodePath<t.InterfaceTypeAnnotation>;

                                                                                                                                                                                                                                                                                                                                method assertInterpreterDirective

                                                                                                                                                                                                                                                                                                                                assertInterpreterDirective: (
                                                                                                                                                                                                                                                                                                                                opts?: object
                                                                                                                                                                                                                                                                                                                                ) => asserts this is NodePath<t.InterpreterDirective>;

                                                                                                                                                                                                                                                                                                                                  method assertIntersectionTypeAnnotation

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

                                                                                                                                                                                                                                                                                                                                    method assertJSX

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

                                                                                                                                                                                                                                                                                                                                      method assertJSXAttribute

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

                                                                                                                                                                                                                                                                                                                                        method assertJSXClosingElement

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

                                                                                                                                                                                                                                                                                                                                          method assertJSXClosingFragment

                                                                                                                                                                                                                                                                                                                                          assertJSXClosingFragment: (
                                                                                                                                                                                                                                                                                                                                          opts?: object
                                                                                                                                                                                                                                                                                                                                          ) => asserts this is NodePath<t.JSXClosingFragment>;

                                                                                                                                                                                                                                                                                                                                            method assertJSXElement

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

                                                                                                                                                                                                                                                                                                                                              method assertJSXEmptyExpression

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

                                                                                                                                                                                                                                                                                                                                                method assertJSXExpressionContainer

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

                                                                                                                                                                                                                                                                                                                                                  method assertJSXFragment

                                                                                                                                                                                                                                                                                                                                                  assertJSXFragment: (opts?: object) => asserts this is NodePath<t.JSXFragment>;

                                                                                                                                                                                                                                                                                                                                                    method assertJSXIdentifier

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

                                                                                                                                                                                                                                                                                                                                                      method assertJSXMemberExpression

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

                                                                                                                                                                                                                                                                                                                                                        method assertJSXNamespacedName

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

                                                                                                                                                                                                                                                                                                                                                          method assertJSXOpeningElement

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

                                                                                                                                                                                                                                                                                                                                                            method assertJSXOpeningFragment

                                                                                                                                                                                                                                                                                                                                                            assertJSXOpeningFragment: (
                                                                                                                                                                                                                                                                                                                                                            opts?: object
                                                                                                                                                                                                                                                                                                                                                            ) => asserts this is NodePath<t.JSXOpeningFragment>;

                                                                                                                                                                                                                                                                                                                                                              method assertJSXSpreadAttribute

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

                                                                                                                                                                                                                                                                                                                                                                method assertJSXSpreadChild

                                                                                                                                                                                                                                                                                                                                                                assertJSXSpreadChild: (
                                                                                                                                                                                                                                                                                                                                                                opts?: object
                                                                                                                                                                                                                                                                                                                                                                ) => asserts this is NodePath<t.JSXSpreadChild>;

                                                                                                                                                                                                                                                                                                                                                                  method assertJSXText

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

                                                                                                                                                                                                                                                                                                                                                                    method assertLabeledStatement

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

                                                                                                                                                                                                                                                                                                                                                                      method assertLiteral

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

                                                                                                                                                                                                                                                                                                                                                                        method assertLogicalExpression

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

                                                                                                                                                                                                                                                                                                                                                                          method assertLoop

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

                                                                                                                                                                                                                                                                                                                                                                            method assertLVal

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

                                                                                                                                                                                                                                                                                                                                                                              method assertMemberExpression

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

                                                                                                                                                                                                                                                                                                                                                                                method assertMetaProperty

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

                                                                                                                                                                                                                                                                                                                                                                                  method assertMethod

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

                                                                                                                                                                                                                                                                                                                                                                                    method assertMiscellaneous

                                                                                                                                                                                                                                                                                                                                                                                    assertMiscellaneous: (
                                                                                                                                                                                                                                                                                                                                                                                    opts?: object
                                                                                                                                                                                                                                                                                                                                                                                    ) => asserts this is NodePath<t.Miscellaneous>;

                                                                                                                                                                                                                                                                                                                                                                                      method assertMixedTypeAnnotation

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

                                                                                                                                                                                                                                                                                                                                                                                        method assertModuleDeclaration

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

                                                                                                                                                                                                                                                                                                                                                                                          method assertModuleExpression

                                                                                                                                                                                                                                                                                                                                                                                          assertModuleExpression: (
                                                                                                                                                                                                                                                                                                                                                                                          opts?: object
                                                                                                                                                                                                                                                                                                                                                                                          ) => asserts this is NodePath<t.ModuleExpression>;

                                                                                                                                                                                                                                                                                                                                                                                            method assertModuleSpecifier

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

                                                                                                                                                                                                                                                                                                                                                                                              method assertNewExpression

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

                                                                                                                                                                                                                                                                                                                                                                                                method assertNoop

                                                                                                                                                                                                                                                                                                                                                                                                assertNoop: (opts?: object) => asserts this is NodePath<t.Noop>;

                                                                                                                                                                                                                                                                                                                                                                                                  method assertNullableTypeAnnotation

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

                                                                                                                                                                                                                                                                                                                                                                                                    method assertNullLiteral

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

                                                                                                                                                                                                                                                                                                                                                                                                      method assertNullLiteralTypeAnnotation

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

                                                                                                                                                                                                                                                                                                                                                                                                        method assertNumberLiteral

                                                                                                                                                                                                                                                                                                                                                                                                        assertNumberLiteral: (
                                                                                                                                                                                                                                                                                                                                                                                                        opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                        ) => asserts this is NodePath<t.NumberLiteral>;
                                                                                                                                                                                                                                                                                                                                                                                                        • Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                          Use assertNumericLiteral

                                                                                                                                                                                                                                                                                                                                                                                                        method assertNumberLiteralTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                        assertNumberLiteralTypeAnnotation: (
                                                                                                                                                                                                                                                                                                                                                                                                        opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                        ) => asserts this is NodePath<t.NumberLiteralTypeAnnotation>;

                                                                                                                                                                                                                                                                                                                                                                                                          method assertNumberTypeAnnotation

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

                                                                                                                                                                                                                                                                                                                                                                                                            method assertNumericLiteral

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

                                                                                                                                                                                                                                                                                                                                                                                                              method assertObjectExpression

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

                                                                                                                                                                                                                                                                                                                                                                                                                method assertObjectMember

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

                                                                                                                                                                                                                                                                                                                                                                                                                  method assertObjectMethod

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

                                                                                                                                                                                                                                                                                                                                                                                                                    method assertObjectPattern

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

                                                                                                                                                                                                                                                                                                                                                                                                                      method assertObjectProperty

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

                                                                                                                                                                                                                                                                                                                                                                                                                        method assertObjectTypeAnnotation

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

                                                                                                                                                                                                                                                                                                                                                                                                                          method assertObjectTypeCallProperty

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

                                                                                                                                                                                                                                                                                                                                                                                                                            method assertObjectTypeIndexer

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

                                                                                                                                                                                                                                                                                                                                                                                                                              method assertObjectTypeInternalSlot

                                                                                                                                                                                                                                                                                                                                                                                                                              assertObjectTypeInternalSlot: (
                                                                                                                                                                                                                                                                                                                                                                                                                              opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                              ) => asserts this is NodePath<t.ObjectTypeInternalSlot>;

                                                                                                                                                                                                                                                                                                                                                                                                                                method assertObjectTypeProperty

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

                                                                                                                                                                                                                                                                                                                                                                                                                                  method assertObjectTypeSpreadProperty

                                                                                                                                                                                                                                                                                                                                                                                                                                  assertObjectTypeSpreadProperty: (
                                                                                                                                                                                                                                                                                                                                                                                                                                  opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => asserts this is NodePath<t.ObjectTypeSpreadProperty>;

                                                                                                                                                                                                                                                                                                                                                                                                                                    method assertOpaqueType

                                                                                                                                                                                                                                                                                                                                                                                                                                    assertOpaqueType: (opts?: object) => asserts this is NodePath<t.OpaqueType>;

                                                                                                                                                                                                                                                                                                                                                                                                                                      method assertOptionalCallExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                      assertOptionalCallExpression: (
                                                                                                                                                                                                                                                                                                                                                                                                                                      opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => asserts this is NodePath<t.OptionalCallExpression>;

                                                                                                                                                                                                                                                                                                                                                                                                                                        method assertOptionalIndexedAccessType

                                                                                                                                                                                                                                                                                                                                                                                                                                        assertOptionalIndexedAccessType: (
                                                                                                                                                                                                                                                                                                                                                                                                                                        opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => asserts this is NodePath<t.OptionalIndexedAccessType>;

                                                                                                                                                                                                                                                                                                                                                                                                                                          method assertOptionalMemberExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                          assertOptionalMemberExpression: (
                                                                                                                                                                                                                                                                                                                                                                                                                                          opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => asserts this is NodePath<t.OptionalMemberExpression>;

                                                                                                                                                                                                                                                                                                                                                                                                                                            method assertParenthesizedExpression

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

                                                                                                                                                                                                                                                                                                                                                                                                                                              method assertPattern

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                method assertPatternLike

                                                                                                                                                                                                                                                                                                                                                                                                                                                assertPatternLike: (opts?: object) => asserts this is NodePath<t.PatternLike>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  method assertPipelineBareFunction

                                                                                                                                                                                                                                                                                                                                                                                                                                                  assertPipelineBareFunction: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                  opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => asserts this is NodePath<t.PipelineBareFunction>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    method assertPipelinePrimaryTopicReference

                                                                                                                                                                                                                                                                                                                                                                                                                                                    assertPipelinePrimaryTopicReference: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                    opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => asserts this is NodePath<t.PipelinePrimaryTopicReference>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      method assertPipelineTopicExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                      assertPipelineTopicExpression: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                      opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => asserts this is NodePath<t.PipelineTopicExpression>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        method assertPlaceholder

                                                                                                                                                                                                                                                                                                                                                                                                                                                        assertPlaceholder: (opts?: object) => asserts this is NodePath<t.Placeholder>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          method assertPrivate

                                                                                                                                                                                                                                                                                                                                                                                                                                                          assertPrivate: (opts?: object) => asserts this is NodePath<t.Private>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            method assertPrivateName

                                                                                                                                                                                                                                                                                                                                                                                                                                                            assertPrivateName: (opts?: object) => asserts this is NodePath<t.PrivateName>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              method assertProgram

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                method assertProperty

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method assertPureish

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method assertQualifiedTypeIdentifier

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method assertRecordExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      assertRecordExpression: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => asserts this is NodePath<t.RecordExpression>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method assertRegexLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        assertRegexLiteral: (opts?: object) => asserts this is NodePath<t.RegexLiteral>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Use assertRegExpLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method assertRegExpLiteral

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method assertRestElement

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method assertRestProperty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            assertRestProperty: (opts?: object) => asserts this is NodePath<t.RestProperty>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Use assertRestElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method assertReturnStatement

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method assertScopable

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method assertSequenceExpression

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method assertSpreadElement

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method assertSpreadProperty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    assertSpreadProperty: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => asserts this is NodePath<t.SpreadProperty>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Use assertSpreadElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method assertStandardized

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    assertStandardized: (opts?: object) => asserts this is NodePath<t.Standardized>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method assertStatement

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method assertStaticBlock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        assertStaticBlock: (opts?: object) => asserts this is NodePath<t.StaticBlock>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method assertStringLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          assertStringLiteral: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => asserts this is NodePath<t.StringLiteral>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method assertStringLiteralTypeAnnotation

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method assertStringTypeAnnotation

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method assertSuper

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method assertSwitchCase

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method assertSwitchStatement

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method assertSymbolTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      assertSymbolTypeAnnotation: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => asserts this is NodePath<t.SymbolTypeAnnotation>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method assertTaggedTemplateExpression

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method assertTemplateElement

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method assertTemplateLiteral

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method assertTerminatorless

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method assertThisExpression

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method assertThisTypeAnnotation

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method assertThrowStatement

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method assertTopicReference

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      assertTopicReference: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => asserts this is NodePath<t.TopicReference>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method assertTryStatement

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method assertTSAnyKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          assertTSAnyKeyword: (opts?: object) => asserts this is NodePath<t.TSAnyKeyword>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method assertTSArrayType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            assertTSArrayType: (opts?: object) => asserts this is NodePath<t.TSArrayType>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method assertTSAsExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              assertTSAsExpression: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => asserts this is NodePath<t.TSAsExpression>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method assertTSBaseType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                assertTSBaseType: (opts?: object) => asserts this is NodePath<t.TSBaseType>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method assertTSBigIntKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  assertTSBigIntKeyword: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => asserts this is NodePath<t.TSBigIntKeyword>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method assertTSBooleanKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    assertTSBooleanKeyword: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => asserts this is NodePath<t.TSBooleanKeyword>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method assertTSCallSignatureDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      assertTSCallSignatureDeclaration: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => asserts this is NodePath<t.TSCallSignatureDeclaration>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method assertTSConditionalType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        assertTSConditionalType: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => asserts this is NodePath<t.TSConditionalType>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method assertTSConstructorType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          assertTSConstructorType: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => asserts this is NodePath<t.TSConstructorType>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method assertTSConstructSignatureDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            assertTSConstructSignatureDeclaration: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => asserts this is NodePath<t.TSConstructSignatureDeclaration>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method assertTSDeclareFunction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              assertTSDeclareFunction: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => asserts this is NodePath<t.TSDeclareFunction>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method assertTSDeclareMethod

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                assertTSDeclareMethod: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => asserts this is NodePath<t.TSDeclareMethod>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method assertTSEntityName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  assertTSEntityName: (opts?: object) => asserts this is NodePath<t.TSEntityName>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method assertTSEnumDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    assertTSEnumDeclaration: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => asserts this is NodePath<t.TSEnumDeclaration>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method assertTSEnumMember

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      assertTSEnumMember: (opts?: object) => asserts this is NodePath<t.TSEnumMember>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method assertTSExportAssignment

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        assertTSExportAssignment: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => asserts this is NodePath<t.TSExportAssignment>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method assertTSExpressionWithTypeArguments

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          assertTSExpressionWithTypeArguments: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => asserts this is NodePath<t.TSExpressionWithTypeArguments>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method assertTSExternalModuleReference

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            assertTSExternalModuleReference: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => asserts this is NodePath<t.TSExternalModuleReference>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method assertTSFunctionType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              assertTSFunctionType: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => asserts this is NodePath<t.TSFunctionType>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method assertTSImportEqualsDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                assertTSImportEqualsDeclaration: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => asserts this is NodePath<t.TSImportEqualsDeclaration>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method assertTSImportType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  assertTSImportType: (opts?: object) => asserts this is NodePath<t.TSImportType>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method assertTSIndexedAccessType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    assertTSIndexedAccessType: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => asserts this is NodePath<t.TSIndexedAccessType>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method assertTSIndexSignature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      assertTSIndexSignature: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => asserts this is NodePath<t.TSIndexSignature>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method assertTSInferType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        assertTSInferType: (opts?: object) => asserts this is NodePath<t.TSInferType>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method assertTSInstantiationExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          assertTSInstantiationExpression: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => asserts this is NodePath<t.TSInstantiationExpression>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method assertTSInterfaceBody

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            assertTSInterfaceBody: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => asserts this is NodePath<t.TSInterfaceBody>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method assertTSInterfaceDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              assertTSInterfaceDeclaration: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => asserts this is NodePath<t.TSInterfaceDeclaration>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method assertTSIntersectionType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                assertTSIntersectionType: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => asserts this is NodePath<t.TSIntersectionType>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method assertTSIntrinsicKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  assertTSIntrinsicKeyword: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => asserts this is NodePath<t.TSIntrinsicKeyword>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method assertTSLiteralType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    assertTSLiteralType: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => asserts this is NodePath<t.TSLiteralType>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method assertTSMappedType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      assertTSMappedType: (opts?: object) => asserts this is NodePath<t.TSMappedType>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method assertTSMethodSignature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        assertTSMethodSignature: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => asserts this is NodePath<t.TSMethodSignature>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method assertTSModuleBlock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          assertTSModuleBlock: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => asserts this is NodePath<t.TSModuleBlock>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method assertTSModuleDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            assertTSModuleDeclaration: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => asserts this is NodePath<t.TSModuleDeclaration>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method assertTSNamedTupleMember

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              assertTSNamedTupleMember: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => asserts this is NodePath<t.TSNamedTupleMember>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method assertTSNamespaceExportDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                assertTSNamespaceExportDeclaration: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => asserts this is NodePath<t.TSNamespaceExportDeclaration>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method assertTSNeverKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  assertTSNeverKeyword: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => asserts this is NodePath<t.TSNeverKeyword>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method assertTSNonNullExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    assertTSNonNullExpression: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => asserts this is NodePath<t.TSNonNullExpression>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method assertTSNullKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      assertTSNullKeyword: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => asserts this is NodePath<t.TSNullKeyword>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method assertTSNumberKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        assertTSNumberKeyword: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => asserts this is NodePath<t.TSNumberKeyword>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method assertTSObjectKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          assertTSObjectKeyword: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => asserts this is NodePath<t.TSObjectKeyword>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method assertTSOptionalType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            assertTSOptionalType: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => asserts this is NodePath<t.TSOptionalType>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method assertTSParameterProperty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              assertTSParameterProperty: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => asserts this is NodePath<t.TSParameterProperty>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method assertTSParenthesizedType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                assertTSParenthesizedType: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => asserts this is NodePath<t.TSParenthesizedType>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method assertTSPropertySignature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  assertTSPropertySignature: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => asserts this is NodePath<t.TSPropertySignature>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method assertTSQualifiedName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    assertTSQualifiedName: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => asserts this is NodePath<t.TSQualifiedName>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method assertTSRestType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      assertTSRestType: (opts?: object) => asserts this is NodePath<t.TSRestType>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method assertTSSatisfiesExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        assertTSSatisfiesExpression: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => asserts this is NodePath<t.TSSatisfiesExpression>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method assertTSStringKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          assertTSStringKeyword: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => asserts this is NodePath<t.TSStringKeyword>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method assertTSSymbolKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            assertTSSymbolKeyword: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => asserts this is NodePath<t.TSSymbolKeyword>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method assertTSThisType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              assertTSThisType: (opts?: object) => asserts this is NodePath<t.TSThisType>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method assertTSTupleType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                assertTSTupleType: (opts?: object) => asserts this is NodePath<t.TSTupleType>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method assertTSType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  assertTSType: (opts?: object) => asserts this is NodePath<t.TSType>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method assertTSTypeAliasDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    assertTSTypeAliasDeclaration: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => asserts this is NodePath<t.TSTypeAliasDeclaration>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method assertTSTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      assertTSTypeAnnotation: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => asserts this is NodePath<t.TSTypeAnnotation>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method assertTSTypeAssertion

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        assertTSTypeAssertion: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => asserts this is NodePath<t.TSTypeAssertion>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method assertTSTypeElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          assertTSTypeElement: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => asserts this is NodePath<t.TSTypeElement>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method assertTSTypeLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            assertTSTypeLiteral: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => asserts this is NodePath<t.TSTypeLiteral>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method assertTSTypeOperator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              assertTSTypeOperator: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => asserts this is NodePath<t.TSTypeOperator>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method assertTSTypeParameter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                assertTSTypeParameter: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => asserts this is NodePath<t.TSTypeParameter>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method assertTSTypeParameterDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  assertTSTypeParameterDeclaration: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => asserts this is NodePath<t.TSTypeParameterDeclaration>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method assertTSTypeParameterInstantiation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    assertTSTypeParameterInstantiation: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => asserts this is NodePath<t.TSTypeParameterInstantiation>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method assertTSTypePredicate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      assertTSTypePredicate: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => asserts this is NodePath<t.TSTypePredicate>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method assertTSTypeQuery

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        assertTSTypeQuery: (opts?: object) => asserts this is NodePath<t.TSTypeQuery>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method assertTSTypeReference

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          assertTSTypeReference: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => asserts this is NodePath<t.TSTypeReference>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method assertTSUndefinedKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            assertTSUndefinedKeyword: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => asserts this is NodePath<t.TSUndefinedKeyword>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method assertTSUnionType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              assertTSUnionType: (opts?: object) => asserts this is NodePath<t.TSUnionType>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method assertTSUnknownKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                assertTSUnknownKeyword: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => asserts this is NodePath<t.TSUnknownKeyword>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method assertTSVoidKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  assertTSVoidKeyword: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => asserts this is NodePath<t.TSVoidKeyword>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method assertTupleExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    assertTupleExpression: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => asserts this is NodePath<t.TupleExpression>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method assertTupleTypeAnnotation

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method assertTypeAlias

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method assertTypeAnnotation

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method assertTypeCastExpression

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method assertTypeofTypeAnnotation

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method assertTypeParameter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                assertTypeParameter: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => asserts this is NodePath<t.TypeParameter>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method assertTypeParameterDeclaration

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method assertTypeParameterInstantiation

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method assertTypeScript

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      assertTypeScript: (opts?: object) => asserts this is NodePath<t.TypeScript>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method assertUnaryExpression

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method assertUnaryLike

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method assertUnionTypeAnnotation

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method assertUpdateExpression

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method assertUserWhitespacable

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method assertV8IntrinsicIdentifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  assertV8IntrinsicIdentifier: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => asserts this is NodePath<t.V8IntrinsicIdentifier>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method assertVariableDeclaration

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method assertVariableDeclarator

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method assertVariance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        assertVariance: (opts?: object) => asserts this is NodePath<t.Variance>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method assertVoidTypeAnnotation

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method assertWhile

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method assertWhileStatement

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method assertWithStatement

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method assertYieldExpression

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method baseTypeStrictlyMatches

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    baseTypeStrictlyMatches: (rightArg: NodePath) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method buildCodeFrameError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      buildCodeFrameError: (msg: string, Error?: ErrorConstructor) => Error;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        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: 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 ensureBlock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ensureBlock: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              this: NodePath<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | t.Loop
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | t.WithStatement
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | t.Function
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | t.LabeledStatement
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | t.CatchClause
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              >
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => asserts this is NodePath<T & { body: t.BlockStatement }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method equals

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method evaluate

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Returns an object in the form { confident, value, deopt }. 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, in which case deopt is the path of said node.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Example:

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method evaluateTruthy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                evaluateTruthy: () => boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • 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 | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Starting at current NodePath and going up the tree, return the first NodePath that causes the provided callback to return a truthy value, or null if the callback never returns a truthy value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method findParent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                findParent: (callback: (path: NodePath) => boolean) => NodePath | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Starting at the parent path of the current NodePath and going up the tree, return the first NodePath that causes the provided callback to return a truthy value, or null if the callback never returns a truthy value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method get

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                static get: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                <C extends Node, K extends keyof C>(opts: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                hub?: HubInterface;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                parentPath: NodePath | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                parent: Node;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                container: C;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                key: K;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }): NodePath<C[K]>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                <C extends Node, L extends NodeKeyOfArrays<C>>(opts: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                hub?: HubInterface;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                parentPath: NodePath<Node>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                parent: Node;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                container: C;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                listKey: L;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                key: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }): C[L] extends any[] ? NodePath<C[L][number]> : never;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method getAllNextSiblings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  getAllNextSiblings: () => NodePath[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method getAllPrevSiblings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    getAllPrevSiblings: () => NodePath[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getAncestry

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getAncestry: () => [this, ...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 getBindingIdentifierPaths

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getBindingIdentifierPaths: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (duplicates: true, outerOnly?: boolean): Record<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Array<NodePath<t.Identifier>>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (duplicates?: false, outerOnly?: boolean): Record<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      NodePath<t.Identifier>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (duplicates?: boolean, outerOnly?: boolean): Record<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      NodePath<t.Identifier> | NodePath<t.Identifier>[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method getBindingIdentifiers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        getBindingIdentifiers: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (duplicates: true): Record<string, t.Identifier[]>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (duplicates?: false): Record<string, t.Identifier>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (duplicates?: boolean): Record<string, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method getCompletionRecords

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getCompletionRecords: () => NodePath[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method getData

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method getDeepestCommonAncestorFrom

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getDeepestCommonAncestorFrom: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              paths: NodePath[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              filter?: (deepest: 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> | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Get the parent function of the current path.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method getNextSibling

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getNextSibling: () => NodePath;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method getOpposite

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                getOpposite: () => NodePath | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method getOuterBindingIdentifierPaths

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  getOuterBindingIdentifierPaths: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (duplicates: true): Record<string, Array<NodePath<t.Identifier>>>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (duplicates?: false): Record<string, NodePath<t.Identifier>>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (duplicates?: boolean, outerOnly?: boolean): Record<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  NodePath<t.Identifier> | NodePath<t.Identifier>[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method getOuterBindingIdentifiers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    getOuterBindingIdentifiers: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (duplicates: true): Record<string, t.Identifier[]>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (duplicates?: false): Record<string, t.Identifier>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (duplicates?: boolean): Record<string, any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      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> | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Walk up the tree until we hit a parent node path in a list.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method getTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getTypeAnnotation: () => t.FlowType | t.TSType;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • 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 hasNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              hasNode: () => this is NodePath<Exclude<T, null>>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                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 extends unknown>(nodes: Nodes) => NodePaths<Nodes>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • 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 extends unknown>(nodes: Nodes) => NodePaths<Nodes>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Insert the provided nodes before the current one.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method inType

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method is

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isAccessor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isAccessor: (opts?: object) => this is NodePath<t.Accessor>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isAncestor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isAncestor: (maybeDescendant: NodePath) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • A helper to find if this path is an ancestor of maybeDescendant

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isAnyTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isAnyTypeAnnotation: (opts?: object) => this is NodePath<t.AnyTypeAnnotation>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isArgumentPlaceholder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isArgumentPlaceholder: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => this is NodePath<t.ArgumentPlaceholder>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        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 isBigIntLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isBigIntLiteral: (opts?: object) => this is NodePath<t.BigIntLiteral>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          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;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    will be removed in Babel 8

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  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 isClassAccessorProperty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isClassAccessorProperty: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => this is NodePath<t.ClassAccessorProperty>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          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 isClassPrivateMethod

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isClassPrivateMethod: (opts?: object) => this is NodePath<t.ClassPrivateMethod>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isClassPrivateProperty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isClassPrivateProperty: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => this is NodePath<t.ClassPrivateProperty>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        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 isConstantExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isConstantExpression: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isContinueStatement

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isDebuggerStatement

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isDecimalLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isDecimalLiteral: (opts?: object) => this is NodePath<t.DecimalLiteral>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method isDeclaration

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isDeclareClass

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isDeclaredPredicate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isDeclaredPredicate: (opts?: object) => this is NodePath<t.DeclaredPredicate>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isDeclareExportAllDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isDeclareExportAllDeclaration: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => this is NodePath<t.DeclareExportAllDeclaration>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isDeclareExportDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isDeclareExportDeclaration: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => this is NodePath<t.DeclareExportDeclaration>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  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 isDeclareModuleExports

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isDeclareModuleExports: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => this is NodePath<t.DeclareModuleExports>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isDeclareOpaqueType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isDeclareOpaqueType: (opts?: object) => this is NodePath<t.DeclareOpaqueType>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            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 isDenylisted

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isDenylisted: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isDescendant

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isDescendant: (maybeAncestor: NodePath) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • A helper to find if this path is a descendant of maybeAncestor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    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 isEmptyTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isEmptyTypeAnnotation: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => this is NodePath<t.EmptyTypeAnnotation>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isEnumBody

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isEnumBody: (opts?: object) => this is NodePath<t.EnumBody>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isEnumBooleanBody

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isEnumBooleanBody: (opts?: object) => this is NodePath<t.EnumBooleanBody>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isEnumBooleanMember

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isEnumBooleanMember: (opts?: object) => this is NodePath<t.EnumBooleanMember>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isEnumDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isEnumDeclaration: (opts?: object) => this is NodePath<t.EnumDeclaration>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method isEnumDefaultedMember

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isEnumDefaultedMember: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => this is NodePath<t.EnumDefaultedMember>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isEnumMember

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isEnumMember: (opts?: object) => this is NodePath<t.EnumMember>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isEnumNumberBody

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isEnumNumberBody: (opts?: object) => this is NodePath<t.EnumNumberBody>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isEnumNumberMember

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isEnumNumberMember: (opts?: object) => this is NodePath<t.EnumNumberMember>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isEnumStringBody

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isEnumStringBody: (opts?: object) => this is NodePath<t.EnumStringBody>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isEnumStringMember

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isEnumStringMember: (opts?: object) => this is NodePath<t.EnumStringMember>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isEnumSymbolBody

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isEnumSymbolBody: (opts?: object) => this is NodePath<t.EnumSymbolBody>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isExistentialTypeParam

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isExistsTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isExistsTypeAnnotation: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => this is NodePath<t.ExistsTypeAnnotation>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        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 isFlowPredicate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isFlowPredicate: (opts?: object) => this is NodePath<t.FlowPredicate>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isFlowType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isFlowType: (opts?: object) => this is NodePath<t.FlowType>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method isFor

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isForAwaitStatement

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            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 isImport

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isImport: (opts?: object) => this is NodePath<t.Import>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isImportAttribute

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isImportAttribute: (opts?: object) => this is NodePath<t.ImportAttribute>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                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 isIndexedAccessType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isIndexedAccessType: (opts?: object) => this is NodePath<t.IndexedAccessType>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isInferredPredicate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isInferredPredicate: (opts?: object) => this is NodePath<t.InferredPredicate>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isInStrictMode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isInStrictMode: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isInterfaceDeclaration

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isInterfaceExtends

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isInterfaceTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isInterfaceTypeAnnotation: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => this is NodePath<t.InterfaceTypeAnnotation>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isInterpreterDirective

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isInterpreterDirective: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => this is NodePath<t.InterpreterDirective>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      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 isJSXClosingFragment

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isJSXClosingFragment: (opts?: object) => this is NodePath<t.JSXClosingFragment>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                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 isJSXFragment

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isJSXFragment: (opts?: object) => this is NodePath<t.JSXFragment>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        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 isJSXOpeningFragment

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isJSXOpeningFragment: (opts?: object) => this is NodePath<t.JSXOpeningFragment>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isJSXSpreadAttribute

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isJSXSpreadChild

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isJSXSpreadChild: (opts?: object) => this is NodePath<t.JSXSpreadChild>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      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 isMiscellaneous

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isMiscellaneous: (opts?: object) => this is NodePath<t.Miscellaneous>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isMixedTypeAnnotation

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isModuleDeclaration

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isModuleExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isModuleExpression: (opts?: object) => this is NodePath<t.ModuleExpression>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                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.NumberLiteral>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Use isNumericLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isNumberLiteralTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isNumberLiteralTypeAnnotation: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => this is NodePath<t.NumberLiteralTypeAnnotation>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              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) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  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 isObjectTypeInternalSlot

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isObjectTypeInternalSlot: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => this is NodePath<t.ObjectTypeInternalSlot>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isObjectTypeProperty

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isObjectTypeSpreadProperty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isObjectTypeSpreadProperty: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => this is NodePath<t.ObjectTypeSpreadProperty>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method isOpaqueType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isOpaqueType: (opts?: object) => this is NodePath<t.OpaqueType>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isOptionalCallExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isOptionalCallExpression: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => this is NodePath<t.OptionalCallExpression>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isOptionalIndexedAccessType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isOptionalIndexedAccessType: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => this is NodePath<t.OptionalIndexedAccessType>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isOptionalMemberExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isOptionalMemberExpression: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => this is NodePath<t.OptionalMemberExpression>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isParenthesizedExpression

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isPattern

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isPatternLike

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isPatternLike: (opts?: object) => this is NodePath<t.PatternLike>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isPipelineBareFunction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isPipelineBareFunction: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => this is NodePath<t.PipelineBareFunction>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method isPipelinePrimaryTopicReference

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isPipelinePrimaryTopicReference: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => this is NodePath<t.PipelinePrimaryTopicReference>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isPipelineTopicExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isPipelineTopicExpression: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => this is NodePath<t.PipelineTopicExpression>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isPlaceholder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isPlaceholder: (opts?: object) => this is NodePath<t.Placeholder>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isPrivate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isPrivate: (opts?: object) => this is NodePath<t.Private>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isPrivateName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isPrivateName: (opts?: object) => this is NodePath<t.PrivateName>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  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 isRecordExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isRecordExpression: (opts?: object) => this is NodePath<t.RecordExpression>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              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.RegexLiteral>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Use isRegExpLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    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>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Use isRestElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        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<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              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>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Use isSpreadElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isStandardized

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isStandardized: (opts?: object) => this is NodePath<t.Standardized>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    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 isStaticBlock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isStaticBlock: (opts?: object) => this is NodePath<t.StaticBlock>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          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 isSymbolTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isSymbolTypeAnnotation: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => this is NodePath<t.SymbolTypeAnnotation>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        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 isTopicReference

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isTopicReference: (opts?: object) => this is NodePath<t.TopicReference>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method isTryStatement

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isTSAnyKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isTSAnyKeyword: (opts?: object) => this is NodePath<t.TSAnyKeyword>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isTSArrayType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isTSArrayType: (opts?: object) => this is NodePath<t.TSArrayType>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isTSAsExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isTSAsExpression: (opts?: object) => this is NodePath<t.TSAsExpression>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isTSBaseType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isTSBaseType: (opts?: object) => this is NodePath<t.TSBaseType>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isTSBigIntKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isTSBigIntKeyword: (opts?: object) => this is NodePath<t.TSBigIntKeyword>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isTSBooleanKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isTSBooleanKeyword: (opts?: object) => this is NodePath<t.TSBooleanKeyword>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isTSCallSignatureDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isTSCallSignatureDeclaration: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => this is NodePath<t.TSCallSignatureDeclaration>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method isTSConditionalType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isTSConditionalType: (opts?: object) => this is NodePath<t.TSConditionalType>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isTSConstructorType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isTSConstructorType: (opts?: object) => this is NodePath<t.TSConstructorType>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isTSConstructSignatureDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isTSConstructSignatureDeclaration: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => this is NodePath<t.TSConstructSignatureDeclaration>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isTSDeclareFunction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isTSDeclareFunction: (opts?: object) => this is NodePath<t.TSDeclareFunction>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isTSDeclareMethod

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isTSDeclareMethod: (opts?: object) => this is NodePath<t.TSDeclareMethod>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isTSEntityName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isTSEntityName: (opts?: object) => this is NodePath<t.TSEntityName>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isTSEnumDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isTSEnumDeclaration: (opts?: object) => this is NodePath<t.TSEnumDeclaration>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isTSEnumMember

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isTSEnumMember: (opts?: object) => this is NodePath<t.TSEnumMember>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method isTSExportAssignment

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isTSExportAssignment: (opts?: object) => this is NodePath<t.TSExportAssignment>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isTSExpressionWithTypeArguments

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isTSExpressionWithTypeArguments: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => this is NodePath<t.TSExpressionWithTypeArguments>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isTSExternalModuleReference

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isTSExternalModuleReference: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => this is NodePath<t.TSExternalModuleReference>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isTSFunctionType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isTSFunctionType: (opts?: object) => this is NodePath<t.TSFunctionType>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isTSImportEqualsDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isTSImportEqualsDeclaration: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => this is NodePath<t.TSImportEqualsDeclaration>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isTSImportType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isTSImportType: (opts?: object) => this is NodePath<t.TSImportType>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isTSIndexedAccessType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isTSIndexedAccessType: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => this is NodePath<t.TSIndexedAccessType>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isTSIndexSignature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isTSIndexSignature: (opts?: object) => this is NodePath<t.TSIndexSignature>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method isTSInferType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isTSInferType: (opts?: object) => this is NodePath<t.TSInferType>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isTSInstantiationExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isTSInstantiationExpression: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => this is NodePath<t.TSInstantiationExpression>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isTSInterfaceBody

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isTSInterfaceBody: (opts?: object) => this is NodePath<t.TSInterfaceBody>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isTSInterfaceDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isTSInterfaceDeclaration: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => this is NodePath<t.TSInterfaceDeclaration>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isTSIntersectionType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isTSIntersectionType: (opts?: object) => this is NodePath<t.TSIntersectionType>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isTSIntrinsicKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isTSIntrinsicKeyword: (opts?: object) => this is NodePath<t.TSIntrinsicKeyword>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isTSLiteralType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isTSLiteralType: (opts?: object) => this is NodePath<t.TSLiteralType>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isTSMappedType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isTSMappedType: (opts?: object) => this is NodePath<t.TSMappedType>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method isTSMethodSignature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isTSMethodSignature: (opts?: object) => this is NodePath<t.TSMethodSignature>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isTSModuleBlock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isTSModuleBlock: (opts?: object) => this is NodePath<t.TSModuleBlock>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isTSModuleDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isTSModuleDeclaration: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => this is NodePath<t.TSModuleDeclaration>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isTSNamedTupleMember

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isTSNamedTupleMember: (opts?: object) => this is NodePath<t.TSNamedTupleMember>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isTSNamespaceExportDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isTSNamespaceExportDeclaration: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => this is NodePath<t.TSNamespaceExportDeclaration>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isTSNeverKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isTSNeverKeyword: (opts?: object) => this is NodePath<t.TSNeverKeyword>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isTSNonNullExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isTSNonNullExpression: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => this is NodePath<t.TSNonNullExpression>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isTSNullKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isTSNullKeyword: (opts?: object) => this is NodePath<t.TSNullKeyword>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method isTSNumberKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isTSNumberKeyword: (opts?: object) => this is NodePath<t.TSNumberKeyword>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isTSObjectKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isTSObjectKeyword: (opts?: object) => this is NodePath<t.TSObjectKeyword>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isTSOptionalType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isTSOptionalType: (opts?: object) => this is NodePath<t.TSOptionalType>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isTSParameterProperty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isTSParameterProperty: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => this is NodePath<t.TSParameterProperty>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isTSParenthesizedType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isTSParenthesizedType: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => this is NodePath<t.TSParenthesizedType>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isTSPropertySignature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isTSPropertySignature: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => this is NodePath<t.TSPropertySignature>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isTSQualifiedName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isTSQualifiedName: (opts?: object) => this is NodePath<t.TSQualifiedName>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isTSRestType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isTSRestType: (opts?: object) => this is NodePath<t.TSRestType>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method isTSSatisfiesExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isTSSatisfiesExpression: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => this is NodePath<t.TSSatisfiesExpression>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isTSStringKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isTSStringKeyword: (opts?: object) => this is NodePath<t.TSStringKeyword>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isTSSymbolKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isTSSymbolKeyword: (opts?: object) => this is NodePath<t.TSSymbolKeyword>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isTSThisType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isTSThisType: (opts?: object) => this is NodePath<t.TSThisType>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isTSTupleType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isTSTupleType: (opts?: object) => this is NodePath<t.TSTupleType>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isTSType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isTSType: (opts?: object) => this is NodePath<t.TSType>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isTSTypeAliasDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isTSTypeAliasDeclaration: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => this is NodePath<t.TSTypeAliasDeclaration>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isTSTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isTSTypeAnnotation: (opts?: object) => this is NodePath<t.TSTypeAnnotation>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method isTSTypeAssertion

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isTSTypeAssertion: (opts?: object) => this is NodePath<t.TSTypeAssertion>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isTSTypeElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isTSTypeElement: (opts?: object) => this is NodePath<t.TSTypeElement>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isTSTypeLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isTSTypeLiteral: (opts?: object) => this is NodePath<t.TSTypeLiteral>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isTSTypeOperator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isTSTypeOperator: (opts?: object) => this is NodePath<t.TSTypeOperator>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isTSTypeParameter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isTSTypeParameter: (opts?: object) => this is NodePath<t.TSTypeParameter>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isTSTypeParameterDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isTSTypeParameterDeclaration: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => this is NodePath<t.TSTypeParameterDeclaration>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isTSTypeParameterInstantiation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isTSTypeParameterInstantiation: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => this is NodePath<t.TSTypeParameterInstantiation>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isTSTypePredicate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isTSTypePredicate: (opts?: object) => this is NodePath<t.TSTypePredicate>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method isTSTypeQuery

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isTSTypeQuery: (opts?: object) => this is NodePath<t.TSTypeQuery>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isTSTypeReference

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isTSTypeReference: (opts?: object) => this is NodePath<t.TSTypeReference>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isTSUndefinedKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isTSUndefinedKeyword: (opts?: object) => this is NodePath<t.TSUndefinedKeyword>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isTSUnionType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isTSUnionType: (opts?: object) => this is NodePath<t.TSUnionType>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method isTSUnknownKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isTSUnknownKeyword: (opts?: object) => this is NodePath<t.TSUnknownKeyword>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isTSVoidKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isTSVoidKeyword: (opts?: object) => this is NodePath<t.TSVoidKeyword>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isTupleExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isTupleExpression: (opts?: object) => this is NodePath<t.TupleExpression>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      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 isTypeParameter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isTypeParameter: (opts?: object) => this is NodePath<t.TypeParameter>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method isTypeParameterDeclaration

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isTypeParameterInstantiation

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isTypeScript

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isTypeScript: (opts?: object) => this is NodePath<t.TypeScript>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        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 isV8IntrinsicIdentifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isV8IntrinsicIdentifier: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => this is NodePath<t.V8IntrinsicIdentifier>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      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 isVariance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isVariance: (opts?: object) => this is NodePath<t.Variance>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              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 pushContainer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          pushContainer: <
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          T extends Node,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          K extends NodeKeyOfArrays<T>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Nodes extends NodesInsertionParam<NodeListType<T, K>>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          this: NodePath<T>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          listKey: K,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          nodes: Nodes
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => NodePaths<Nodes>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Insert child nodes at the end of the current node.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter listKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The key at which the child nodes are stored (usually body).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter nodes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            the nodes to insert.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          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: t.Statement[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => NodePaths<t.Expression | t.Statement>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • 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 extends unknown>(nodes: Nodes) => NodePaths<Nodes>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method replaceWith

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                replaceWith: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                <R extends Node>(replacementPath: R | NodePath<R>): [NodePath<R>];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                <R extends NodePath<Node>>(replacementPath: R): [R];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Replace the current node with another.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method replaceWithMultiple

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                replaceWithMultiple: <Nodes extends unknown>(nodes: Nodes) => NodePaths<Nodes>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • 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: string) => [NodePath];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • 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 requeue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                requeue: (pathToQueue?: NodePath) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method resolve

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  resolve: (dangerous?: boolean, resolved?: NodePath[]) => NodePath;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method resync

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    resync: () => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Here we resync the node paths key and container. If they've changed according to what we have stored internally then we attempt to resync by crawling and looking for the new values.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method set

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method setContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      setContext: (context?: TraversalContext) => this;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method setData

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        setData: (key: string | symbol, 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 toComputedKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  toComputedKey: () => t.PrivateName | t.Expression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method traverse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    traverse: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    <T>(visitor: TraverseOptions<T>, state: T): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (visitor: TraverseOptions<Node>): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method unshiftContainer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      unshiftContainer: <
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      T extends Node,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      K extends NodeKeyOfArrays<T>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Nodes extends NodesInsertionParam<NodeListType<T, K>>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      >(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      this: NodePath<T>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      listKey: K,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      nodes: Nodes
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => NodePaths<Nodes>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Insert child nodes at the start of the current node.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameter listKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The key at which the child nodes are stored (usually body).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Parameter nodes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        the nodes to insert.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method unwrapFunctionEnvironment

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      unwrapFunctionEnvironment: () => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Given an arbitrary function, process its content as if it were an arrow function, moving references to "this", "arguments", "super", and such into the function's parent scope. This method is useful if you have wrapped some set of items in an IIFE or other function, but want "this", "arguments", and super" to continue behaving as expected.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method updateSiblingKeys

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method visit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      visit: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method willIMaybeExecuteBefore

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class Scope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class Scope {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          constructor(path: NodePath<Node>, parentScope?: Scope);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • This searches the current "scope" and collects all references/bindings within.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property bindings

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property block

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            block: Node;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property contextVariables

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              static contextVariables: string[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Variables available in current context.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property crawling

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              crawling: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property data

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                data: Record<string | symbol, unknown>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property globals

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  static globals: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property globals

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    globals: { [name: string]: any };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property hub

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      hub: HubInterface;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property labels

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        labels: Map<string, NodePath<t.LabeledStatement>>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property parent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          parent: Scope;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property parentBlock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            parentBlock: Node;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              path: NodePath<Node>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property references

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                references: { [name: string]: true };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property uid

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  uid: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property uids

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    uids: { [name: string]: boolean };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method addGlobal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      addGlobal: (node: t.Identifier | t.JSXIdentifier) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method bindingIdentifierEquals

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method buildUndefinedNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          buildUndefinedNode: () => t.UnaryExpression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method checkBlockScopedCollisions

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method crawl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              crawl: () => 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: Node,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  defaultName?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => t.Identifier;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Generate a unique identifier based on a node.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method getAllBindings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  getAllBindings: () => Record<string, Binding>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Walks the scope tree and gathers **all** bindings.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method getAllBindingsOfKind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  getAllBindingsOfKind: (...kinds: string[]) => Record<string, Binding>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Walks the scope tree and gathers all declarations of kind.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method getBinding

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method getBindingIdentifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    getBindingIdentifier: (name: string) => t.Identifier;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getBlockParent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getBlockParent: () => Scope;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Walk up the scope tree until we hit either a BlockStatement/Loop/Program/Function/Switch or reach the very top and hit Program.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getData

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getData: (key: string) => any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Recursively walk up scope tree looking for the data key.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getFunctionParent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getFunctionParent: () => Scope | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Walk up the scope tree until we hit either a Function or return null.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getLabel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getLabel: (name: string) => NodePath<t.LabeledStatement> | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method getOwnBinding

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method getOwnBindingIdentifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getOwnBindingIdentifier: (name: string) => t.Identifier;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method getPatternParent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            getPatternParent: () => Scope;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Walk up from a pattern scope (function param initializer) until we hit a non-pattern scope, then returns its block parent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              An ancestry scope whose path is a block parent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method getProgramParent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            getProgramParent: () => Scope;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Walk up to the top of the scope tree and get the Program.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method hasBinding

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            hasBinding: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            name: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            optsOrNoGlobals?: boolean | { noGlobals?: boolean; noUids?: boolean }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method hasGlobal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              hasGlobal: (name: string) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method hasLabel

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isStatic

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isStatic: (node: 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: 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,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          opts?: { noGlobals?: boolean; noUids?: boolean }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method push

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            push: (opts: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            id: t.LVal;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            init?: t.Expression;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            unique?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            _blockHoist?: number | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            kind?: 'var' | 'let' | 'const';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method registerBinding

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method registerConstantViolation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                registerConstantViolation: (path: NodePath) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method registerDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  registerDeclaration: (path: NodePath) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method registerLabel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    registerLabel: (path: NodePath<t.LabeledStatement>) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method removeBinding

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      removeBinding: (name: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method removeData

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        removeData: (key: string) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Recursively walk up scope tree looking for the data key and if it exists, remove it.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method removeOwnBinding

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        removeOwnBinding: (name: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method rename

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method setData

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            setData: (key: string, val: any) => any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Set some arbitrary data on the current scope.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method toArray

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            toArray: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            node: t.Node,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            i?: number | boolean,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            arrayLikeIsIterable?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => t.ArrayExpression | t.CallExpression | t.Identifier;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method traverse

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Interfaces

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface HubInterface

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface HubInterface {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method addHelper

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                addHelper: (name: string) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method buildError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  buildError: (node: Node, msg: string, Error: ErrorConstructor) => Error;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method getCode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    getCode: () => string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getScope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getScope: () => Scope | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface TraversalContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface TraversalContext<S = unknown> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property opts

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          opts: TraverseOptions;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property parentPath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            parentPath: NodePath;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property scope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              scope: Scope;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property state

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                state: S;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface VirtualTypeAliases

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface VirtualTypeAliases {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property BindingIdentifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    BindingIdentifier: t.Identifier;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property BlockScoped

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      BlockScoped: Node;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property ExistentialTypeParam

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ExistentialTypeParam: t.ExistsTypeAnnotation;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property Flow

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Flow: t.Flow | t.ImportDeclaration | t.ExportDeclaration | t.ImportSpecifier;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property ForAwaitStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ForAwaitStatement: t.ForOfStatement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property Generated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Generated: Node;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property NumericLiteralTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                NumericLiteralTypeAnnotation: t.NumberLiteralTypeAnnotation;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property Pure

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Pure: Node;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property Referenced

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Referenced: Node;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property ReferencedIdentifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ReferencedIdentifier: t.Identifier | t.JSXIdentifier;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property ReferencedMemberExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ReferencedMemberExpression: t.MemberExpression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property RestProperty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          RestProperty: t.RestElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property Scope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Scope: t.Scopable | t.Pattern;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property SpreadProperty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              SpreadProperty: t.RestElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property User

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                User: Node;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property Var

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Var: t.VariableDeclaration;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface VisitNodeObject

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface VisitNodeObject<S, P extends Node> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property enter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      enter?: VisitNodeFunction<S, P>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property exit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        exit?: VisitNodeFunction<S, P>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Type Aliases

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type BindingKind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type BindingKind =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'var'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'let'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'const'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'module'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'hoisted'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'param'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'local'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'unknown';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type NodeKeyOfArrays

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type NodeKeyOfArrays<T extends Node> = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [P in keyof T]-?: T[P] extends Array<Node | null | undefined> ? P : never;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }[keyof T];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type NodeKeyOfNodes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type NodeKeyOfNodes<T extends Node> = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              [P in keyof T]-?: T[P] extends Node | null | undefined ? P : never;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }[keyof T];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type NodePathResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type NodePathResult<T> =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | (Extract<T, Node | null | undefined> extends never
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ? never
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                : NodePath<Extract<T, Node | null | undefined>>)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | (T extends Array<Node | null | undefined>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ? Array<NodePath<T[number]>>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                : never);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type NodePaths

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type NodePaths<T extends Node | readonly Node[]> = T extends readonly Node[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ? { -readonly [K in keyof T]: NodePath<Extract<T[K], Node>> }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  : T extends Node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ? [NodePath<T>]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  : never;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type TraverseOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type TraverseOptions<S = Node> = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    scope?: Scope;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    noScope?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    denylist?: NodeType[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    /** @deprecated will be removed in Babel 8 */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    blacklist?: NodeType[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    shouldSkip?: (node: NodePath) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    } & Visitor<S>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type VisitNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type VisitNode<S, P extends Node> = VisitNodeFunction<S, P> | VisitNodeObject<S, P>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type VisitNodeFunction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type VisitNodeFunction<S, P extends Node> = (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        this: S,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        path: NodePath<P>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        state: S
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type Visitor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type Visitor<S = unknown> = VisitNodeObject<S, Node> & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [N in Node as N['type']]?: VisitNode<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          S,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          N extends { type: N['type'] } ? N : never
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          } & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [K in keyof t.Aliases]?: VisitNode<S, t.Aliases[K]>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          } & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [K in keyof VirtualTypeAliases]?: VisitNode<S, VirtualTypeAliases[K]>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          } & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          // Babel supports `NodeTypesWithoutComment | NodeTypesWithoutComment | ... ` but it is
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          // too complex for TS. So we type it as a general visitor only if the key contains `|`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          // this is good enough for non-visitor traverse options e.g. `noScope`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [k: `${string}|${string}`]: VisitNode<S, Node>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Namespaces

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            namespace cache

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            namespace cache {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              variable path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              let path: WeakMap<t.Node, Map<t.Node, NodePath<Node>>>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                variable scope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                let scope: WeakMap<t.Node, Scope>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function clear

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  clear: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function clearPath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    clearPath: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function clearScope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      clearScope: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        namespace visitors

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        namespace visitors {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function explode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          explode: <S = unknown>(visitor: Visitor<S>) => {};
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • explode() will take a Visitor object with all of the various shorthands that we support, and validates & normalizes it into a common format, ready to be used in traversal.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The various shorthands are: - Identifier() { ... } -> Identifier: { enter() { ... } } - "Identifier|NumericLiteral": { ... } -> Identifier: { ... }, NumericLiteral: { ... } - Aliases in @babel/types: e.g. Property: { ... } -> ObjectProperty: { ... }, ClassProperty: { ... }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Other normalizations are: - Visitors of virtual types are wrapped, so that they are only visited when their dynamic check passes - enter and exit functions are wrapped in arrays, to ease merging of visitors

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function merge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          merge: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          <State>(visitors: Array<Visitor<State>>): Visitor<State>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          visitors: Visitor<unknown>[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          states?: any[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          wrapper?: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          stateKey: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          visitorKey: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func: VisitNodeFunction<unknown, Node>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => VisitNodeFunction<unknown, Node>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ): Visitor<unknown>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function verify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            verify: (visitor: Visitor) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Package Files (1)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Dependencies (1)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Dev Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              No dev dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Peer Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              No peer dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Badge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@types/babel__traverse.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Markdown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@types/babel__traverse)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • HTML
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                <a href="https://www.jsdocs.io/package/@types/babel__traverse"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>