From 32dfc31b1f22629161d5599cb865a5cb031a4e7c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Hu=C3=A1ng=20J=C3=B9nli=C3=A0ng?= <jlhwung@gmail.com>
Date: Fri, 8 Jul 2022 10:16:12 -0400
Subject: [PATCH] typings: intersect input node types for is* functions

---
 .../src/decorators.ts                         |   18 +-
 .../src/misc.ts                               |    2 +-
 .../src/index.ts                              |    2 +-
 .../babel-helper-replace-supers/src/index.ts  |   22 +-
 .../babel-helper-wrap-function/src/index.ts   |   30 +-
 .../src/util.ts                               |   12 +-
 .../src/index.ts                              |    5 +-
 .../src/transformer-2021-12.ts                |    4 +-
 .../src/index.ts                              |   11 +-
 .../src/enum.ts                               |    5 +-
 .../scripts/generators/validators.js          |    6 +-
 .../src/path/generated/validators.ts          | 1692 ++++++++++++-----
 packages/babel-traverse/src/path/index.ts     |    2 +-
 .../babel-traverse/src/path/introspection.ts  |   13 +-
 14 files changed, 1322 insertions(+), 502 deletions(-)

diff --git a/packages/babel-helper-create-class-features-plugin/src/decorators.ts b/packages/babel-helper-create-class-features-plugin/src/decorators.ts
index a3d721a5412d..d2acfde94c61 100644
--- a/packages/babel-helper-create-class-features-plugin/src/decorators.ts
+++ b/packages/babel-helper-create-class-features-plugin/src/decorators.ts
@@ -94,13 +94,17 @@ function extractElementDescriptor(
 
   const { node, scope } = path as NodePath<SupportedElement>;
 
-  new ReplaceSupers({
-    methodPath: path,
-    objectRef: classRef,
-    superRef,
-    file,
-    refToPreserve: classRef,
-  }).replace();
+  if (!path.isTSDeclareMethod()) {
+    new ReplaceSupers({
+      methodPath: path as NodePath<
+        Exclude<SupportedElement, t.TSDeclareMethod>
+      >,
+      objectRef: classRef,
+      superRef,
+      file,
+      refToPreserve: classRef,
+    }).replace();
+  }
 
   const properties: t.ObjectExpression["properties"] = [
     prop("kind", t.stringLiteral(t.isClassMethod(node) ? node.kind : "field")),
diff --git a/packages/babel-helper-create-class-features-plugin/src/misc.ts b/packages/babel-helper-create-class-features-plugin/src/misc.ts
index 3908941dc0d6..9352f69dad1b 100644
--- a/packages/babel-helper-create-class-features-plugin/src/misc.ts
+++ b/packages/babel-helper-create-class-features-plugin/src/misc.ts
@@ -122,7 +122,7 @@ export function extractComputedKeys(
   };
   for (const computedPath of computedPaths) {
     const computedKey = computedPath.get("key");
-    if (computedKey.isIdentifier() && computedKey.isReferencedIdentifier()) {
+    if (computedKey.isReferencedIdentifier()) {
       handleClassTDZ(computedKey, state);
     } else {
       computedKey.traverse(classFieldDefinitionEvaluationTDZVisitor, state);
diff --git a/packages/babel-helper-remap-async-to-generator/src/index.ts b/packages/babel-helper-remap-async-to-generator/src/index.ts
index 876372f6110c..e0a114362b3d 100644
--- a/packages/babel-helper-remap-async-to-generator/src/index.ts
+++ b/packages/babel-helper-remap-async-to-generator/src/index.ts
@@ -36,7 +36,7 @@ const awaitVisitor = traverse.visitors.merge<{ wrapAwait: t.Expression }>([
 ]);
 
 export default function (
-  path: NodePath<any>,
+  path: NodePath<t.Function>,
   helpers: {
     wrapAsync: t.Expression;
     wrapAwait?: t.Expression;
diff --git a/packages/babel-helper-replace-supers/src/index.ts b/packages/babel-helper-replace-supers/src/index.ts
index b59c35850339..3e60b1b30cec 100644
--- a/packages/babel-helper-replace-supers/src/index.ts
+++ b/packages/babel-helper-replace-supers/src/index.ts
@@ -1,4 +1,4 @@
-import type { HubInterface, NodePath, Scope } from "@babel/traverse";
+import type { NodePath, Scope } from "@babel/traverse";
 import traverse from "@babel/traverse";
 import memberExpressionToFunctions from "@babel/helper-member-expression-to-functions";
 import type { HandlerState } from "@babel/helper-member-expression-to-functions";
@@ -317,9 +317,16 @@ const looseHandlers = {
 };
 
 type ReplaceSupersOptionsBase = {
-  methodPath: NodePath<any>;
+  methodPath: NodePath<
+    | t.ClassMethod
+    | t.ClassProperty
+    | t.ObjectMethod
+    | t.ClassPrivateMethod
+    | t.ClassPrivateProperty
+    | t.StaticBlock
+  >;
   constantSuper?: boolean;
-  file: any;
+  file: File;
   // objectRef might have been shadowed in child scopes,
   // in that case, we need to rename related variables.
   refToPreserve?: t.Identifier;
@@ -336,7 +343,7 @@ type ReplaceSupersOptions = ReplaceSupersOptionsBase &
   );
 
 interface ReplaceState {
-  file: unknown;
+  file: File;
   scope: Scope;
   isDerivedConstructor: boolean;
   isStatic: boolean;
@@ -353,7 +360,10 @@ export default class ReplaceSupers {
     this.isDerivedConstructor =
       path.isClassMethod({ kind: "constructor" }) && !!opts.superRef;
     this.isStatic =
-      path.isObjectMethod() || path.node.static || path.isStaticBlock?.();
+      path.isObjectMethod() ||
+      // @ts-expect-error static is not in ClassPrivateMethod
+      path.node.static ||
+      path.isStaticBlock?.();
     this.isPrivateMethod = path.isPrivate() && path.isMethod();
 
     this.file = opts.file;
@@ -364,7 +374,7 @@ export default class ReplaceSupers {
     this.opts = opts;
   }
 
-  declare file: HubInterface;
+  declare file: File;
   declare isDerivedConstructor: boolean;
   declare constantSuper: boolean;
   declare isPrivateMethod: boolean;
diff --git a/packages/babel-helper-wrap-function/src/index.ts b/packages/babel-helper-wrap-function/src/index.ts
index b02014eea6bb..eb2f906d98e7 100644
--- a/packages/babel-helper-wrap-function/src/index.ts
+++ b/packages/babel-helper-wrap-function/src/index.ts
@@ -40,7 +40,7 @@ const buildDeclarationWrapper = template.statements(`
 
 function classOrObjectMethod(
   path: NodePath<t.ClassMethod | t.ClassPrivateMethod | t.ObjectMethod>,
-  callId: any,
+  callId: t.Expression,
 ) {
   const node = path.node;
   const body = node.body;
@@ -67,13 +67,17 @@ function classOrObjectMethod(
 }
 
 function plainFunction(
-  path: NodePath<any>,
-  callId: any,
+  path: NodePath<Exclude<t.Function, t.Method>>,
+  callId: t.Expression,
   noNewArrows: boolean,
   ignoreFunctionLength: boolean,
 ) {
+  if (path.isArrowFunctionExpression()) {
+    path.arrowFunctionToExpression({ noNewArrows });
+  }
   const node = path.node;
   const isDeclaration = path.isFunctionDeclaration();
+  // @ts-expect-error node is FunctionDeclaration|FunctionExpression
   const functionId = node.id;
   const wrapper = isDeclaration
     ? buildDeclarationWrapper
@@ -81,17 +85,16 @@ function plainFunction(
     ? buildNamedExpressionWrapper
     : buildAnonymousExpressionWrapper;
 
-  if (path.isArrowFunctionExpression()) {
-    path.arrowFunctionToExpression({ noNewArrows });
-  }
-
+  // @ts-expect-error node is FunctionDeclaration|FunctionExpression
   node.id = null;
 
   if (isDeclaration) {
     node.type = "FunctionExpression";
   }
 
-  const built = callExpression(callId, [node]);
+  const built = callExpression(callId, [
+    node as Exclude<t.Function, t.Method | t.FunctionDeclaration>,
+  ]);
 
   const params: t.Identifier[] = [];
   for (const param of node.params) {
@@ -138,8 +141,8 @@ function plainFunction(
 }
 
 export default function wrapFunction(
-  path: NodePath,
-  callId: any,
+  path: NodePath<t.Function>,
+  callId: t.Expression,
   // TODO(Babel 8): Consider defaulting to false for spec compliancy
   noNewArrows: boolean = true,
   ignoreFunctionLength: boolean = false,
@@ -147,6 +150,11 @@ export default function wrapFunction(
   if (path.isMethod()) {
     classOrObjectMethod(path, callId);
   } else {
-    plainFunction(path, callId, noNewArrows, ignoreFunctionLength);
+    plainFunction(
+      path as NodePath<Exclude<t.Function, t.Method>>,
+      callId,
+      noNewArrows,
+      ignoreFunctionLength,
+    );
   }
 }
diff --git a/packages/babel-plugin-bugfix-v8-spread-parameters-in-optional-chaining/src/util.ts b/packages/babel-plugin-bugfix-v8-spread-parameters-in-optional-chaining/src/util.ts
index 0c3f0863185c..afbc7cbdf3be 100644
--- a/packages/babel-plugin-bugfix-v8-spread-parameters-in-optional-chaining/src/util.ts
+++ b/packages/babel-plugin-bugfix-v8-spread-parameters-in-optional-chaining/src/util.ts
@@ -24,17 +24,15 @@ export function shouldTransform(
 ): boolean {
   let optionalPath: NodePath<t.Expression> = path;
   const chains = [];
-  while (
-    optionalPath.isOptionalMemberExpression() ||
-    optionalPath.isOptionalCallExpression()
-  ) {
-    const { node } = optionalPath;
-    chains.push(node);
-
+  for (;;) {
     if (optionalPath.isOptionalMemberExpression()) {
       optionalPath = skipTransparentExprWrappers(optionalPath.get("object"));
+      chains.push(optionalPath.node);
     } else if (optionalPath.isOptionalCallExpression()) {
       optionalPath = skipTransparentExprWrappers(optionalPath.get("callee"));
+      chains.push(optionalPath.node);
+    } else {
+      break;
     }
   }
   for (let i = 0; i < chains.length; i++) {
diff --git a/packages/babel-plugin-proposal-class-static-block/src/index.ts b/packages/babel-plugin-proposal-class-static-block/src/index.ts
index 120fa50e7e1a..ed596bd04468 100644
--- a/packages/babel-plugin-proposal-class-static-block/src/index.ts
+++ b/packages/babel-plugin-proposal-class-static-block/src/index.ts
@@ -49,10 +49,7 @@ export default declare(({ types: t, template, assertVersion }) => {
         const body = classBody.get("body");
         for (const path of body) {
           if (path.isPrivate()) {
-            privateNames.add(
-              // @ts-expect-error TS can't infer that NodePath<t.ClassBody[body][number]> & NodePath<t.Private> equals to NodePath<t.ClassBody[body][number] & isPrivate>
-              path.get("key.id").node.name,
-            );
+            privateNames.add(path.get("key.id").node.name);
           }
         }
         for (const path of body) {
diff --git a/packages/babel-plugin-proposal-decorators/src/transformer-2021-12.ts b/packages/babel-plugin-proposal-decorators/src/transformer-2021-12.ts
index 10af52865a2f..53011ef94fda 100644
--- a/packages/babel-plugin-proposal-decorators/src/transformer-2021-12.ts
+++ b/packages/babel-plugin-proposal-decorators/src/transformer-2021-12.ts
@@ -685,10 +685,10 @@ function transformClass(
 
           const replaceSupers = new ReplaceSupers({
             constantSuper,
-            methodPath: element,
+            methodPath: element as NodePath<t.ClassPrivateMethod>,
             objectRef: classLocal,
             superRef: path.node.superClass,
-            file: state,
+            file: state.file,
             refToPreserve: classLocal,
           });
 
diff --git a/packages/babel-plugin-proposal-object-rest-spread/src/index.ts b/packages/babel-plugin-proposal-object-rest-spread/src/index.ts
index 76205389cb49..876f93a9a6d2 100644
--- a/packages/babel-plugin-proposal-object-rest-spread/src/index.ts
+++ b/packages/babel-plugin-proposal-object-rest-spread/src/index.ts
@@ -243,7 +243,9 @@ export default declare((api, opts: Options) => {
 
   function replaceRestElement(
     parentPath: NodePath<t.Function | t.CatchClause>,
-    paramPath: Param | NodePath<t.AssignmentPattern["left"]>,
+    paramPath: NodePath<
+      t.Function["params"][number] | t.AssignmentPattern["left"]
+    >,
     container?: t.VariableDeclaration[],
   ): void {
     if (paramPath.isAssignmentPattern()) {
@@ -255,12 +257,7 @@ export default declare((api, opts: Options) => {
       const elements = paramPath.get("elements");
 
       for (let i = 0; i < elements.length; i++) {
-        replaceRestElement(
-          parentPath,
-          // @ts-expect-error Fixme: handle TSAsExpression
-          elements[i],
-          container,
-        );
+        replaceRestElement(parentPath, elements[i], container);
       }
     }
 
diff --git a/packages/babel-plugin-transform-typescript/src/enum.ts b/packages/babel-plugin-transform-typescript/src/enum.ts
index b39559d54a0b..9a3234286f69 100644
--- a/packages/babel-plugin-transform-typescript/src/enum.ts
+++ b/packages/babel-plugin-transform-typescript/src/enum.ts
@@ -156,10 +156,7 @@ export function translateEnumValues(
       } else {
         const initializerPath = memberPath.get("initializer");
 
-        if (
-          initializerPath.isIdentifier() &&
-          initializerPath.isReferencedIdentifier()
-        ) {
+        if (initializerPath.isReferencedIdentifier()) {
           ReferencedIdentifier(initializerPath, {
             t,
             seen,
diff --git a/packages/babel-traverse/scripts/generators/validators.js b/packages/babel-traverse/scripts/generators/validators.js
index 3a2dbe29dae0..1dca02cd48f8 100644
--- a/packages/babel-traverse/scripts/generators/validators.js
+++ b/packages/babel-traverse/scripts/generators/validators.js
@@ -14,7 +14,7 @@ export interface NodePathValidators {
 `;
 
   for (const type of [...t.TYPES].sort()) {
-    output += `is${type}(opts?: object): this is NodePath<t.${type}>;`;
+    output += `is${type}<T extends t.Node>(this: NodePath<T>, opts?: object): this is NodePath<T & t.${type}>;`;
   }
 
   for (const type of Object.keys(virtualTypes)) {
@@ -24,9 +24,9 @@ export interface NodePathValidators {
     const { types } = virtualTypes[type];
     if (type[0] === "_") continue;
     if (t.NODE_FIELDS[type] || t.FLIPPED_ALIAS_KEYS[type]) {
-      output += `is${type}(opts?: object): this is NodePath<t.${type}>;`;
+      output += `is${type}<T extends t.Node>(this: NodePath<T>, opts?: object): this is NodePath<T & t.${type}>;`;
     } else if (types /* in VirtualTypeAliases */) {
-      output += `is${type}(opts?: object): this is NodePath<VirtualTypeAliases["${type}"]>;`;
+      output += `is${type}<T extends t.Node>(this: NodePath<T>, opts?: object): this is NodePath<T & VirtualTypeAliases["${type}"]>;`;
     } else if (type === "Pure") {
       output += `isPure(constantsOnly?: boolean): boolean;`;
     } else {
diff --git a/packages/babel-traverse/src/path/generated/validators.ts b/packages/babel-traverse/src/path/generated/validators.ts
index bd1c9a31b351..7271088faca8 100644
--- a/packages/babel-traverse/src/path/generated/validators.ts
+++ b/packages/babel-traverse/src/path/generated/validators.ts
@@ -7,459 +7,1265 @@ import NodePath from "../index";
 import type { VirtualTypeAliases } from "./virtual-types";
 
 export interface NodePathValidators {
-  isAccessor(opts?: object): this is NodePath<t.Accessor>;
-  isAnyTypeAnnotation(opts?: object): this is NodePath<t.AnyTypeAnnotation>;
-  isArgumentPlaceholder(opts?: object): this is NodePath<t.ArgumentPlaceholder>;
-  isArrayExpression(opts?: object): this is NodePath<t.ArrayExpression>;
-  isArrayPattern(opts?: object): this is NodePath<t.ArrayPattern>;
-  isArrayTypeAnnotation(opts?: object): this is NodePath<t.ArrayTypeAnnotation>;
-  isArrowFunctionExpression(
-    opts?: object,
-  ): this is NodePath<t.ArrowFunctionExpression>;
-  isAssignmentExpression(
-    opts?: object,
-  ): this is NodePath<t.AssignmentExpression>;
-  isAssignmentPattern(opts?: object): this is NodePath<t.AssignmentPattern>;
-  isAwaitExpression(opts?: object): this is NodePath<t.AwaitExpression>;
-  isBigIntLiteral(opts?: object): this is NodePath<t.BigIntLiteral>;
-  isBinary(opts?: object): this is NodePath<t.Binary>;
-  isBinaryExpression(opts?: object): this is NodePath<t.BinaryExpression>;
-  isBindExpression(opts?: object): this is NodePath<t.BindExpression>;
-  isBlock(opts?: object): this is NodePath<t.Block>;
-  isBlockParent(opts?: object): this is NodePath<t.BlockParent>;
-  isBlockStatement(opts?: object): this is NodePath<t.BlockStatement>;
-  isBooleanLiteral(opts?: object): this is NodePath<t.BooleanLiteral>;
-  isBooleanLiteralTypeAnnotation(
-    opts?: object,
-  ): this is NodePath<t.BooleanLiteralTypeAnnotation>;
-  isBooleanTypeAnnotation(
-    opts?: object,
-  ): this is NodePath<t.BooleanTypeAnnotation>;
-  isBreakStatement(opts?: object): this is NodePath<t.BreakStatement>;
-  isCallExpression(opts?: object): this is NodePath<t.CallExpression>;
-  isCatchClause(opts?: object): this is NodePath<t.CatchClause>;
-  isClass(opts?: object): this is NodePath<t.Class>;
-  isClassAccessorProperty(
-    opts?: object,
-  ): this is NodePath<t.ClassAccessorProperty>;
-  isClassBody(opts?: object): this is NodePath<t.ClassBody>;
-  isClassDeclaration(opts?: object): this is NodePath<t.ClassDeclaration>;
-  isClassExpression(opts?: object): this is NodePath<t.ClassExpression>;
-  isClassImplements(opts?: object): this is NodePath<t.ClassImplements>;
-  isClassMethod(opts?: object): this is NodePath<t.ClassMethod>;
-  isClassPrivateMethod(opts?: object): this is NodePath<t.ClassPrivateMethod>;
-  isClassPrivateProperty(
-    opts?: object,
-  ): this is NodePath<t.ClassPrivateProperty>;
-  isClassProperty(opts?: object): this is NodePath<t.ClassProperty>;
-  isCompletionStatement(opts?: object): this is NodePath<t.CompletionStatement>;
-  isConditional(opts?: object): this is NodePath<t.Conditional>;
-  isConditionalExpression(
-    opts?: object,
-  ): this is NodePath<t.ConditionalExpression>;
-  isContinueStatement(opts?: object): this is NodePath<t.ContinueStatement>;
-  isDebuggerStatement(opts?: object): this is NodePath<t.DebuggerStatement>;
-  isDecimalLiteral(opts?: object): this is NodePath<t.DecimalLiteral>;
-  isDeclaration(opts?: object): this is NodePath<t.Declaration>;
-  isDeclareClass(opts?: object): this is NodePath<t.DeclareClass>;
-  isDeclareExportAllDeclaration(
-    opts?: object,
-  ): this is NodePath<t.DeclareExportAllDeclaration>;
-  isDeclareExportDeclaration(
-    opts?: object,
-  ): this is NodePath<t.DeclareExportDeclaration>;
-  isDeclareFunction(opts?: object): this is NodePath<t.DeclareFunction>;
-  isDeclareInterface(opts?: object): this is NodePath<t.DeclareInterface>;
-  isDeclareModule(opts?: object): this is NodePath<t.DeclareModule>;
-  isDeclareModuleExports(
-    opts?: object,
-  ): this is NodePath<t.DeclareModuleExports>;
-  isDeclareOpaqueType(opts?: object): this is NodePath<t.DeclareOpaqueType>;
-  isDeclareTypeAlias(opts?: object): this is NodePath<t.DeclareTypeAlias>;
-  isDeclareVariable(opts?: object): this is NodePath<t.DeclareVariable>;
-  isDeclaredPredicate(opts?: object): this is NodePath<t.DeclaredPredicate>;
-  isDecorator(opts?: object): this is NodePath<t.Decorator>;
-  isDirective(opts?: object): this is NodePath<t.Directive>;
-  isDirectiveLiteral(opts?: object): this is NodePath<t.DirectiveLiteral>;
-  isDoExpression(opts?: object): this is NodePath<t.DoExpression>;
-  isDoWhileStatement(opts?: object): this is NodePath<t.DoWhileStatement>;
-  isEmptyStatement(opts?: object): this is NodePath<t.EmptyStatement>;
-  isEmptyTypeAnnotation(opts?: object): this is NodePath<t.EmptyTypeAnnotation>;
-  isEnumBody(opts?: object): this is NodePath<t.EnumBody>;
-  isEnumBooleanBody(opts?: object): this is NodePath<t.EnumBooleanBody>;
-  isEnumBooleanMember(opts?: object): this is NodePath<t.EnumBooleanMember>;
-  isEnumDeclaration(opts?: object): this is NodePath<t.EnumDeclaration>;
-  isEnumDefaultedMember(opts?: object): this is NodePath<t.EnumDefaultedMember>;
-  isEnumMember(opts?: object): this is NodePath<t.EnumMember>;
-  isEnumNumberBody(opts?: object): this is NodePath<t.EnumNumberBody>;
-  isEnumNumberMember(opts?: object): this is NodePath<t.EnumNumberMember>;
-  isEnumStringBody(opts?: object): this is NodePath<t.EnumStringBody>;
-  isEnumStringMember(opts?: object): this is NodePath<t.EnumStringMember>;
-  isEnumSymbolBody(opts?: object): this is NodePath<t.EnumSymbolBody>;
-  isExistsTypeAnnotation(
-    opts?: object,
-  ): this is NodePath<t.ExistsTypeAnnotation>;
-  isExportAllDeclaration(
-    opts?: object,
-  ): this is NodePath<t.ExportAllDeclaration>;
-  isExportDeclaration(opts?: object): this is NodePath<t.ExportDeclaration>;
-  isExportDefaultDeclaration(
-    opts?: object,
-  ): this is NodePath<t.ExportDefaultDeclaration>;
-  isExportDefaultSpecifier(
-    opts?: object,
-  ): this is NodePath<t.ExportDefaultSpecifier>;
-  isExportNamedDeclaration(
-    opts?: object,
-  ): this is NodePath<t.ExportNamedDeclaration>;
-  isExportNamespaceSpecifier(
-    opts?: object,
-  ): this is NodePath<t.ExportNamespaceSpecifier>;
-  isExportSpecifier(opts?: object): this is NodePath<t.ExportSpecifier>;
-  isExpression(opts?: object): this is NodePath<t.Expression>;
-  isExpressionStatement(opts?: object): this is NodePath<t.ExpressionStatement>;
-  isExpressionWrapper(opts?: object): this is NodePath<t.ExpressionWrapper>;
-  isFile(opts?: object): this is NodePath<t.File>;
-  isFlow(opts?: object): this is NodePath<t.Flow>;
-  isFlowBaseAnnotation(opts?: object): this is NodePath<t.FlowBaseAnnotation>;
-  isFlowDeclaration(opts?: object): this is NodePath<t.FlowDeclaration>;
-  isFlowPredicate(opts?: object): this is NodePath<t.FlowPredicate>;
-  isFlowType(opts?: object): this is NodePath<t.FlowType>;
-  isFor(opts?: object): this is NodePath<t.For>;
-  isForInStatement(opts?: object): this is NodePath<t.ForInStatement>;
-  isForOfStatement(opts?: object): this is NodePath<t.ForOfStatement>;
-  isForStatement(opts?: object): this is NodePath<t.ForStatement>;
-  isForXStatement(opts?: object): this is NodePath<t.ForXStatement>;
-  isFunction(opts?: object): this is NodePath<t.Function>;
-  isFunctionDeclaration(opts?: object): this is NodePath<t.FunctionDeclaration>;
-  isFunctionExpression(opts?: object): this is NodePath<t.FunctionExpression>;
-  isFunctionParent(opts?: object): this is NodePath<t.FunctionParent>;
-  isFunctionTypeAnnotation(
-    opts?: object,
-  ): this is NodePath<t.FunctionTypeAnnotation>;
-  isFunctionTypeParam(opts?: object): this is NodePath<t.FunctionTypeParam>;
-  isGenericTypeAnnotation(
-    opts?: object,
-  ): this is NodePath<t.GenericTypeAnnotation>;
-  isIdentifier(opts?: object): this is NodePath<t.Identifier>;
-  isIfStatement(opts?: object): this is NodePath<t.IfStatement>;
-  isImmutable(opts?: object): this is NodePath<t.Immutable>;
-  isImport(opts?: object): this is NodePath<t.Import>;
-  isImportAttribute(opts?: object): this is NodePath<t.ImportAttribute>;
-  isImportDeclaration(opts?: object): this is NodePath<t.ImportDeclaration>;
-  isImportDefaultSpecifier(
-    opts?: object,
-  ): this is NodePath<t.ImportDefaultSpecifier>;
-  isImportNamespaceSpecifier(
-    opts?: object,
-  ): this is NodePath<t.ImportNamespaceSpecifier>;
-  isImportSpecifier(opts?: object): this is NodePath<t.ImportSpecifier>;
-  isIndexedAccessType(opts?: object): this is NodePath<t.IndexedAccessType>;
-  isInferredPredicate(opts?: object): this is NodePath<t.InferredPredicate>;
-  isInterfaceDeclaration(
-    opts?: object,
-  ): this is NodePath<t.InterfaceDeclaration>;
-  isInterfaceExtends(opts?: object): this is NodePath<t.InterfaceExtends>;
-  isInterfaceTypeAnnotation(
-    opts?: object,
-  ): this is NodePath<t.InterfaceTypeAnnotation>;
-  isInterpreterDirective(
-    opts?: object,
-  ): this is NodePath<t.InterpreterDirective>;
-  isIntersectionTypeAnnotation(
-    opts?: object,
-  ): this is NodePath<t.IntersectionTypeAnnotation>;
-  isJSX(opts?: object): this is NodePath<t.JSX>;
-  isJSXAttribute(opts?: object): this is NodePath<t.JSXAttribute>;
-  isJSXClosingElement(opts?: object): this is NodePath<t.JSXClosingElement>;
-  isJSXClosingFragment(opts?: object): this is NodePath<t.JSXClosingFragment>;
-  isJSXElement(opts?: object): this is NodePath<t.JSXElement>;
-  isJSXEmptyExpression(opts?: object): this is NodePath<t.JSXEmptyExpression>;
-  isJSXExpressionContainer(
-    opts?: object,
-  ): this is NodePath<t.JSXExpressionContainer>;
-  isJSXFragment(opts?: object): this is NodePath<t.JSXFragment>;
-  isJSXIdentifier(opts?: object): this is NodePath<t.JSXIdentifier>;
-  isJSXMemberExpression(opts?: object): this is NodePath<t.JSXMemberExpression>;
-  isJSXNamespacedName(opts?: object): this is NodePath<t.JSXNamespacedName>;
-  isJSXOpeningElement(opts?: object): this is NodePath<t.JSXOpeningElement>;
-  isJSXOpeningFragment(opts?: object): this is NodePath<t.JSXOpeningFragment>;
-  isJSXSpreadAttribute(opts?: object): this is NodePath<t.JSXSpreadAttribute>;
-  isJSXSpreadChild(opts?: object): this is NodePath<t.JSXSpreadChild>;
-  isJSXText(opts?: object): this is NodePath<t.JSXText>;
-  isLVal(opts?: object): this is NodePath<t.LVal>;
-  isLabeledStatement(opts?: object): this is NodePath<t.LabeledStatement>;
-  isLiteral(opts?: object): this is NodePath<t.Literal>;
-  isLogicalExpression(opts?: object): this is NodePath<t.LogicalExpression>;
-  isLoop(opts?: object): this is NodePath<t.Loop>;
-  isMemberExpression(opts?: object): this is NodePath<t.MemberExpression>;
-  isMetaProperty(opts?: object): this is NodePath<t.MetaProperty>;
-  isMethod(opts?: object): this is NodePath<t.Method>;
-  isMiscellaneous(opts?: object): this is NodePath<t.Miscellaneous>;
-  isMixedTypeAnnotation(opts?: object): this is NodePath<t.MixedTypeAnnotation>;
-  isModuleDeclaration(opts?: object): this is NodePath<t.ModuleDeclaration>;
-  isModuleExpression(opts?: object): this is NodePath<t.ModuleExpression>;
-  isModuleSpecifier(opts?: object): this is NodePath<t.ModuleSpecifier>;
-  isNewExpression(opts?: object): this is NodePath<t.NewExpression>;
-  isNoop(opts?: object): this is NodePath<t.Noop>;
-  isNullLiteral(opts?: object): this is NodePath<t.NullLiteral>;
-  isNullLiteralTypeAnnotation(
-    opts?: object,
-  ): this is NodePath<t.NullLiteralTypeAnnotation>;
-  isNullableTypeAnnotation(
-    opts?: object,
-  ): this is NodePath<t.NullableTypeAnnotation>;
-  isNumberLiteral(opts?: object): this is NodePath<t.NumberLiteral>;
-  isNumberLiteralTypeAnnotation(
-    opts?: object,
-  ): this is NodePath<t.NumberLiteralTypeAnnotation>;
-  isNumberTypeAnnotation(
-    opts?: object,
-  ): this is NodePath<t.NumberTypeAnnotation>;
-  isNumericLiteral(opts?: object): this is NodePath<t.NumericLiteral>;
-  isObjectExpression(opts?: object): this is NodePath<t.ObjectExpression>;
-  isObjectMember(opts?: object): this is NodePath<t.ObjectMember>;
-  isObjectMethod(opts?: object): this is NodePath<t.ObjectMethod>;
-  isObjectPattern(opts?: object): this is NodePath<t.ObjectPattern>;
-  isObjectProperty(opts?: object): this is NodePath<t.ObjectProperty>;
-  isObjectTypeAnnotation(
-    opts?: object,
-  ): this is NodePath<t.ObjectTypeAnnotation>;
-  isObjectTypeCallProperty(
-    opts?: object,
-  ): this is NodePath<t.ObjectTypeCallProperty>;
-  isObjectTypeIndexer(opts?: object): this is NodePath<t.ObjectTypeIndexer>;
-  isObjectTypeInternalSlot(
-    opts?: object,
-  ): this is NodePath<t.ObjectTypeInternalSlot>;
-  isObjectTypeProperty(opts?: object): this is NodePath<t.ObjectTypeProperty>;
-  isObjectTypeSpreadProperty(
-    opts?: object,
-  ): this is NodePath<t.ObjectTypeSpreadProperty>;
-  isOpaqueType(opts?: object): this is NodePath<t.OpaqueType>;
-  isOptionalCallExpression(
-    opts?: object,
-  ): this is NodePath<t.OptionalCallExpression>;
-  isOptionalIndexedAccessType(
-    opts?: object,
-  ): this is NodePath<t.OptionalIndexedAccessType>;
-  isOptionalMemberExpression(
-    opts?: object,
-  ): this is NodePath<t.OptionalMemberExpression>;
-  isParenthesizedExpression(
-    opts?: object,
-  ): this is NodePath<t.ParenthesizedExpression>;
-  isPattern(opts?: object): this is NodePath<t.Pattern>;
-  isPatternLike(opts?: object): this is NodePath<t.PatternLike>;
-  isPipelineBareFunction(
-    opts?: object,
-  ): this is NodePath<t.PipelineBareFunction>;
-  isPipelinePrimaryTopicReference(
-    opts?: object,
-  ): this is NodePath<t.PipelinePrimaryTopicReference>;
-  isPipelineTopicExpression(
-    opts?: object,
-  ): this is NodePath<t.PipelineTopicExpression>;
-  isPlaceholder(opts?: object): this is NodePath<t.Placeholder>;
-  isPrivate(opts?: object): this is NodePath<t.Private>;
-  isPrivateName(opts?: object): this is NodePath<t.PrivateName>;
-  isProgram(opts?: object): this is NodePath<t.Program>;
-  isProperty(opts?: object): this is NodePath<t.Property>;
-  isPureish(opts?: object): this is NodePath<t.Pureish>;
-  isQualifiedTypeIdentifier(
-    opts?: object,
-  ): this is NodePath<t.QualifiedTypeIdentifier>;
-  isRecordExpression(opts?: object): this is NodePath<t.RecordExpression>;
-  isRegExpLiteral(opts?: object): this is NodePath<t.RegExpLiteral>;
-  isRegexLiteral(opts?: object): this is NodePath<t.RegexLiteral>;
-  isRestElement(opts?: object): this is NodePath<t.RestElement>;
-  isRestProperty(opts?: object): this is NodePath<t.RestProperty>;
-  isReturnStatement(opts?: object): this is NodePath<t.ReturnStatement>;
-  isScopable(opts?: object): this is NodePath<t.Scopable>;
-  isSequenceExpression(opts?: object): this is NodePath<t.SequenceExpression>;
-  isSpreadElement(opts?: object): this is NodePath<t.SpreadElement>;
-  isSpreadProperty(opts?: object): this is NodePath<t.SpreadProperty>;
-  isStandardized(opts?: object): this is NodePath<t.Standardized>;
-  isStatement(opts?: object): this is NodePath<t.Statement>;
-  isStaticBlock(opts?: object): this is NodePath<t.StaticBlock>;
-  isStringLiteral(opts?: object): this is NodePath<t.StringLiteral>;
-  isStringLiteralTypeAnnotation(
-    opts?: object,
-  ): this is NodePath<t.StringLiteralTypeAnnotation>;
-  isStringTypeAnnotation(
-    opts?: object,
-  ): this is NodePath<t.StringTypeAnnotation>;
-  isSuper(opts?: object): this is NodePath<t.Super>;
-  isSwitchCase(opts?: object): this is NodePath<t.SwitchCase>;
-  isSwitchStatement(opts?: object): this is NodePath<t.SwitchStatement>;
-  isSymbolTypeAnnotation(
-    opts?: object,
-  ): this is NodePath<t.SymbolTypeAnnotation>;
-  isTSAnyKeyword(opts?: object): this is NodePath<t.TSAnyKeyword>;
-  isTSArrayType(opts?: object): this is NodePath<t.TSArrayType>;
-  isTSAsExpression(opts?: object): this is NodePath<t.TSAsExpression>;
-  isTSBaseType(opts?: object): this is NodePath<t.TSBaseType>;
-  isTSBigIntKeyword(opts?: object): this is NodePath<t.TSBigIntKeyword>;
-  isTSBooleanKeyword(opts?: object): this is NodePath<t.TSBooleanKeyword>;
-  isTSCallSignatureDeclaration(
-    opts?: object,
-  ): this is NodePath<t.TSCallSignatureDeclaration>;
-  isTSConditionalType(opts?: object): this is NodePath<t.TSConditionalType>;
-  isTSConstructSignatureDeclaration(
-    opts?: object,
-  ): this is NodePath<t.TSConstructSignatureDeclaration>;
-  isTSConstructorType(opts?: object): this is NodePath<t.TSConstructorType>;
-  isTSDeclareFunction(opts?: object): this is NodePath<t.TSDeclareFunction>;
-  isTSDeclareMethod(opts?: object): this is NodePath<t.TSDeclareMethod>;
-  isTSEntityName(opts?: object): this is NodePath<t.TSEntityName>;
-  isTSEnumDeclaration(opts?: object): this is NodePath<t.TSEnumDeclaration>;
-  isTSEnumMember(opts?: object): this is NodePath<t.TSEnumMember>;
-  isTSExportAssignment(opts?: object): this is NodePath<t.TSExportAssignment>;
-  isTSExpressionWithTypeArguments(
-    opts?: object,
-  ): this is NodePath<t.TSExpressionWithTypeArguments>;
-  isTSExternalModuleReference(
-    opts?: object,
-  ): this is NodePath<t.TSExternalModuleReference>;
-  isTSFunctionType(opts?: object): this is NodePath<t.TSFunctionType>;
-  isTSImportEqualsDeclaration(
-    opts?: object,
-  ): this is NodePath<t.TSImportEqualsDeclaration>;
-  isTSImportType(opts?: object): this is NodePath<t.TSImportType>;
-  isTSIndexSignature(opts?: object): this is NodePath<t.TSIndexSignature>;
-  isTSIndexedAccessType(opts?: object): this is NodePath<t.TSIndexedAccessType>;
-  isTSInferType(opts?: object): this is NodePath<t.TSInferType>;
-  isTSInstantiationExpression(
-    opts?: object,
-  ): this is NodePath<t.TSInstantiationExpression>;
-  isTSInterfaceBody(opts?: object): this is NodePath<t.TSInterfaceBody>;
-  isTSInterfaceDeclaration(
-    opts?: object,
-  ): this is NodePath<t.TSInterfaceDeclaration>;
-  isTSIntersectionType(opts?: object): this is NodePath<t.TSIntersectionType>;
-  isTSIntrinsicKeyword(opts?: object): this is NodePath<t.TSIntrinsicKeyword>;
-  isTSLiteralType(opts?: object): this is NodePath<t.TSLiteralType>;
-  isTSMappedType(opts?: object): this is NodePath<t.TSMappedType>;
-  isTSMethodSignature(opts?: object): this is NodePath<t.TSMethodSignature>;
-  isTSModuleBlock(opts?: object): this is NodePath<t.TSModuleBlock>;
-  isTSModuleDeclaration(opts?: object): this is NodePath<t.TSModuleDeclaration>;
-  isTSNamedTupleMember(opts?: object): this is NodePath<t.TSNamedTupleMember>;
-  isTSNamespaceExportDeclaration(
-    opts?: object,
-  ): this is NodePath<t.TSNamespaceExportDeclaration>;
-  isTSNeverKeyword(opts?: object): this is NodePath<t.TSNeverKeyword>;
-  isTSNonNullExpression(opts?: object): this is NodePath<t.TSNonNullExpression>;
-  isTSNullKeyword(opts?: object): this is NodePath<t.TSNullKeyword>;
-  isTSNumberKeyword(opts?: object): this is NodePath<t.TSNumberKeyword>;
-  isTSObjectKeyword(opts?: object): this is NodePath<t.TSObjectKeyword>;
-  isTSOptionalType(opts?: object): this is NodePath<t.TSOptionalType>;
-  isTSParameterProperty(opts?: object): this is NodePath<t.TSParameterProperty>;
-  isTSParenthesizedType(opts?: object): this is NodePath<t.TSParenthesizedType>;
-  isTSPropertySignature(opts?: object): this is NodePath<t.TSPropertySignature>;
-  isTSQualifiedName(opts?: object): this is NodePath<t.TSQualifiedName>;
-  isTSRestType(opts?: object): this is NodePath<t.TSRestType>;
-  isTSStringKeyword(opts?: object): this is NodePath<t.TSStringKeyword>;
-  isTSSymbolKeyword(opts?: object): this is NodePath<t.TSSymbolKeyword>;
-  isTSThisType(opts?: object): this is NodePath<t.TSThisType>;
-  isTSTupleType(opts?: object): this is NodePath<t.TSTupleType>;
-  isTSType(opts?: object): this is NodePath<t.TSType>;
-  isTSTypeAliasDeclaration(
-    opts?: object,
-  ): this is NodePath<t.TSTypeAliasDeclaration>;
-  isTSTypeAnnotation(opts?: object): this is NodePath<t.TSTypeAnnotation>;
-  isTSTypeAssertion(opts?: object): this is NodePath<t.TSTypeAssertion>;
-  isTSTypeElement(opts?: object): this is NodePath<t.TSTypeElement>;
-  isTSTypeLiteral(opts?: object): this is NodePath<t.TSTypeLiteral>;
-  isTSTypeOperator(opts?: object): this is NodePath<t.TSTypeOperator>;
-  isTSTypeParameter(opts?: object): this is NodePath<t.TSTypeParameter>;
-  isTSTypeParameterDeclaration(
-    opts?: object,
-  ): this is NodePath<t.TSTypeParameterDeclaration>;
-  isTSTypeParameterInstantiation(
-    opts?: object,
-  ): this is NodePath<t.TSTypeParameterInstantiation>;
-  isTSTypePredicate(opts?: object): this is NodePath<t.TSTypePredicate>;
-  isTSTypeQuery(opts?: object): this is NodePath<t.TSTypeQuery>;
-  isTSTypeReference(opts?: object): this is NodePath<t.TSTypeReference>;
-  isTSUndefinedKeyword(opts?: object): this is NodePath<t.TSUndefinedKeyword>;
-  isTSUnionType(opts?: object): this is NodePath<t.TSUnionType>;
-  isTSUnknownKeyword(opts?: object): this is NodePath<t.TSUnknownKeyword>;
-  isTSVoidKeyword(opts?: object): this is NodePath<t.TSVoidKeyword>;
-  isTaggedTemplateExpression(
-    opts?: object,
-  ): this is NodePath<t.TaggedTemplateExpression>;
-  isTemplateElement(opts?: object): this is NodePath<t.TemplateElement>;
-  isTemplateLiteral(opts?: object): this is NodePath<t.TemplateLiteral>;
-  isTerminatorless(opts?: object): this is NodePath<t.Terminatorless>;
-  isThisExpression(opts?: object): this is NodePath<t.ThisExpression>;
-  isThisTypeAnnotation(opts?: object): this is NodePath<t.ThisTypeAnnotation>;
-  isThrowStatement(opts?: object): this is NodePath<t.ThrowStatement>;
-  isTopicReference(opts?: object): this is NodePath<t.TopicReference>;
-  isTryStatement(opts?: object): this is NodePath<t.TryStatement>;
-  isTupleExpression(opts?: object): this is NodePath<t.TupleExpression>;
-  isTupleTypeAnnotation(opts?: object): this is NodePath<t.TupleTypeAnnotation>;
-  isTypeAlias(opts?: object): this is NodePath<t.TypeAlias>;
-  isTypeAnnotation(opts?: object): this is NodePath<t.TypeAnnotation>;
-  isTypeCastExpression(opts?: object): this is NodePath<t.TypeCastExpression>;
-  isTypeParameter(opts?: object): this is NodePath<t.TypeParameter>;
-  isTypeParameterDeclaration(
-    opts?: object,
-  ): this is NodePath<t.TypeParameterDeclaration>;
-  isTypeParameterInstantiation(
-    opts?: object,
-  ): this is NodePath<t.TypeParameterInstantiation>;
-  isTypeScript(opts?: object): this is NodePath<t.TypeScript>;
-  isTypeofTypeAnnotation(
-    opts?: object,
-  ): this is NodePath<t.TypeofTypeAnnotation>;
-  isUnaryExpression(opts?: object): this is NodePath<t.UnaryExpression>;
-  isUnaryLike(opts?: object): this is NodePath<t.UnaryLike>;
-  isUnionTypeAnnotation(opts?: object): this is NodePath<t.UnionTypeAnnotation>;
-  isUpdateExpression(opts?: object): this is NodePath<t.UpdateExpression>;
-  isUserWhitespacable(opts?: object): this is NodePath<t.UserWhitespacable>;
-  isV8IntrinsicIdentifier(
-    opts?: object,
-  ): this is NodePath<t.V8IntrinsicIdentifier>;
-  isVariableDeclaration(opts?: object): this is NodePath<t.VariableDeclaration>;
-  isVariableDeclarator(opts?: object): this is NodePath<t.VariableDeclarator>;
-  isVariance(opts?: object): this is NodePath<t.Variance>;
-  isVoidTypeAnnotation(opts?: object): this is NodePath<t.VoidTypeAnnotation>;
-  isWhile(opts?: object): this is NodePath<t.While>;
-  isWhileStatement(opts?: object): this is NodePath<t.WhileStatement>;
-  isWithStatement(opts?: object): this is NodePath<t.WithStatement>;
-  isYieldExpression(opts?: object): this is NodePath<t.YieldExpression>;
-  isBindingIdentifier(
-    opts?: object,
-  ): this is NodePath<VirtualTypeAliases["BindingIdentifier"]>;
+  isAccessor<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.Accessor>;
+  isAnyTypeAnnotation<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.AnyTypeAnnotation>;
+  isArgumentPlaceholder<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.ArgumentPlaceholder>;
+  isArrayExpression<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.ArrayExpression>;
+  isArrayPattern<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.ArrayPattern>;
+  isArrayTypeAnnotation<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.ArrayTypeAnnotation>;
+  isArrowFunctionExpression<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.ArrowFunctionExpression>;
+  isAssignmentExpression<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.AssignmentExpression>;
+  isAssignmentPattern<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.AssignmentPattern>;
+  isAwaitExpression<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.AwaitExpression>;
+  isBigIntLiteral<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.BigIntLiteral>;
+  isBinary<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.Binary>;
+  isBinaryExpression<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.BinaryExpression>;
+  isBindExpression<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.BindExpression>;
+  isBlock<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.Block>;
+  isBlockParent<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.BlockParent>;
+  isBlockStatement<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.BlockStatement>;
+  isBooleanLiteral<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.BooleanLiteral>;
+  isBooleanLiteralTypeAnnotation<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.BooleanLiteralTypeAnnotation>;
+  isBooleanTypeAnnotation<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.BooleanTypeAnnotation>;
+  isBreakStatement<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.BreakStatement>;
+  isCallExpression<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.CallExpression>;
+  isCatchClause<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.CatchClause>;
+  isClass<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.Class>;
+  isClassAccessorProperty<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.ClassAccessorProperty>;
+  isClassBody<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.ClassBody>;
+  isClassDeclaration<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.ClassDeclaration>;
+  isClassExpression<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.ClassExpression>;
+  isClassImplements<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.ClassImplements>;
+  isClassMethod<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.ClassMethod>;
+  isClassPrivateMethod<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.ClassPrivateMethod>;
+  isClassPrivateProperty<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.ClassPrivateProperty>;
+  isClassProperty<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.ClassProperty>;
+  isCompletionStatement<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.CompletionStatement>;
+  isConditional<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.Conditional>;
+  isConditionalExpression<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.ConditionalExpression>;
+  isContinueStatement<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.ContinueStatement>;
+  isDebuggerStatement<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.DebuggerStatement>;
+  isDecimalLiteral<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.DecimalLiteral>;
+  isDeclaration<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.Declaration>;
+  isDeclareClass<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.DeclareClass>;
+  isDeclareExportAllDeclaration<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.DeclareExportAllDeclaration>;
+  isDeclareExportDeclaration<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.DeclareExportDeclaration>;
+  isDeclareFunction<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.DeclareFunction>;
+  isDeclareInterface<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.DeclareInterface>;
+  isDeclareModule<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.DeclareModule>;
+  isDeclareModuleExports<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.DeclareModuleExports>;
+  isDeclareOpaqueType<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.DeclareOpaqueType>;
+  isDeclareTypeAlias<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.DeclareTypeAlias>;
+  isDeclareVariable<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.DeclareVariable>;
+  isDeclaredPredicate<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.DeclaredPredicate>;
+  isDecorator<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.Decorator>;
+  isDirective<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.Directive>;
+  isDirectiveLiteral<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.DirectiveLiteral>;
+  isDoExpression<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.DoExpression>;
+  isDoWhileStatement<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.DoWhileStatement>;
+  isEmptyStatement<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.EmptyStatement>;
+  isEmptyTypeAnnotation<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.EmptyTypeAnnotation>;
+  isEnumBody<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.EnumBody>;
+  isEnumBooleanBody<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.EnumBooleanBody>;
+  isEnumBooleanMember<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.EnumBooleanMember>;
+  isEnumDeclaration<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.EnumDeclaration>;
+  isEnumDefaultedMember<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.EnumDefaultedMember>;
+  isEnumMember<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.EnumMember>;
+  isEnumNumberBody<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.EnumNumberBody>;
+  isEnumNumberMember<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.EnumNumberMember>;
+  isEnumStringBody<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.EnumStringBody>;
+  isEnumStringMember<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.EnumStringMember>;
+  isEnumSymbolBody<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.EnumSymbolBody>;
+  isExistsTypeAnnotation<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.ExistsTypeAnnotation>;
+  isExportAllDeclaration<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.ExportAllDeclaration>;
+  isExportDeclaration<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.ExportDeclaration>;
+  isExportDefaultDeclaration<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.ExportDefaultDeclaration>;
+  isExportDefaultSpecifier<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.ExportDefaultSpecifier>;
+  isExportNamedDeclaration<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.ExportNamedDeclaration>;
+  isExportNamespaceSpecifier<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.ExportNamespaceSpecifier>;
+  isExportSpecifier<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.ExportSpecifier>;
+  isExpression<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.Expression>;
+  isExpressionStatement<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.ExpressionStatement>;
+  isExpressionWrapper<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.ExpressionWrapper>;
+  isFile<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.File>;
+  isFlow<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.Flow>;
+  isFlowBaseAnnotation<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.FlowBaseAnnotation>;
+  isFlowDeclaration<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.FlowDeclaration>;
+  isFlowPredicate<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.FlowPredicate>;
+  isFlowType<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.FlowType>;
+  isFor<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.For>;
+  isForInStatement<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.ForInStatement>;
+  isForOfStatement<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.ForOfStatement>;
+  isForStatement<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.ForStatement>;
+  isForXStatement<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.ForXStatement>;
+  isFunction<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.Function>;
+  isFunctionDeclaration<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.FunctionDeclaration>;
+  isFunctionExpression<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.FunctionExpression>;
+  isFunctionParent<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.FunctionParent>;
+  isFunctionTypeAnnotation<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.FunctionTypeAnnotation>;
+  isFunctionTypeParam<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.FunctionTypeParam>;
+  isGenericTypeAnnotation<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.GenericTypeAnnotation>;
+  isIdentifier<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.Identifier>;
+  isIfStatement<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.IfStatement>;
+  isImmutable<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.Immutable>;
+  isImport<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.Import>;
+  isImportAttribute<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.ImportAttribute>;
+  isImportDeclaration<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.ImportDeclaration>;
+  isImportDefaultSpecifier<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.ImportDefaultSpecifier>;
+  isImportNamespaceSpecifier<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.ImportNamespaceSpecifier>;
+  isImportSpecifier<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.ImportSpecifier>;
+  isIndexedAccessType<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.IndexedAccessType>;
+  isInferredPredicate<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.InferredPredicate>;
+  isInterfaceDeclaration<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.InterfaceDeclaration>;
+  isInterfaceExtends<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.InterfaceExtends>;
+  isInterfaceTypeAnnotation<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.InterfaceTypeAnnotation>;
+  isInterpreterDirective<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.InterpreterDirective>;
+  isIntersectionTypeAnnotation<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.IntersectionTypeAnnotation>;
+  isJSX<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.JSX>;
+  isJSXAttribute<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.JSXAttribute>;
+  isJSXClosingElement<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.JSXClosingElement>;
+  isJSXClosingFragment<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.JSXClosingFragment>;
+  isJSXElement<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.JSXElement>;
+  isJSXEmptyExpression<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.JSXEmptyExpression>;
+  isJSXExpressionContainer<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.JSXExpressionContainer>;
+  isJSXFragment<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.JSXFragment>;
+  isJSXIdentifier<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.JSXIdentifier>;
+  isJSXMemberExpression<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.JSXMemberExpression>;
+  isJSXNamespacedName<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.JSXNamespacedName>;
+  isJSXOpeningElement<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.JSXOpeningElement>;
+  isJSXOpeningFragment<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.JSXOpeningFragment>;
+  isJSXSpreadAttribute<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.JSXSpreadAttribute>;
+  isJSXSpreadChild<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.JSXSpreadChild>;
+  isJSXText<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.JSXText>;
+  isLVal<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.LVal>;
+  isLabeledStatement<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.LabeledStatement>;
+  isLiteral<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.Literal>;
+  isLogicalExpression<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.LogicalExpression>;
+  isLoop<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.Loop>;
+  isMemberExpression<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.MemberExpression>;
+  isMetaProperty<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.MetaProperty>;
+  isMethod<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.Method>;
+  isMiscellaneous<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.Miscellaneous>;
+  isMixedTypeAnnotation<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.MixedTypeAnnotation>;
+  isModuleDeclaration<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.ModuleDeclaration>;
+  isModuleExpression<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.ModuleExpression>;
+  isModuleSpecifier<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.ModuleSpecifier>;
+  isNewExpression<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.NewExpression>;
+  isNoop<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.Noop>;
+  isNullLiteral<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.NullLiteral>;
+  isNullLiteralTypeAnnotation<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.NullLiteralTypeAnnotation>;
+  isNullableTypeAnnotation<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.NullableTypeAnnotation>;
+  isNumberLiteral<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.NumberLiteral>;
+  isNumberLiteralTypeAnnotation<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.NumberLiteralTypeAnnotation>;
+  isNumberTypeAnnotation<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.NumberTypeAnnotation>;
+  isNumericLiteral<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.NumericLiteral>;
+  isObjectExpression<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.ObjectExpression>;
+  isObjectMember<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.ObjectMember>;
+  isObjectMethod<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.ObjectMethod>;
+  isObjectPattern<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.ObjectPattern>;
+  isObjectProperty<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.ObjectProperty>;
+  isObjectTypeAnnotation<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.ObjectTypeAnnotation>;
+  isObjectTypeCallProperty<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.ObjectTypeCallProperty>;
+  isObjectTypeIndexer<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.ObjectTypeIndexer>;
+  isObjectTypeInternalSlot<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.ObjectTypeInternalSlot>;
+  isObjectTypeProperty<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.ObjectTypeProperty>;
+  isObjectTypeSpreadProperty<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.ObjectTypeSpreadProperty>;
+  isOpaqueType<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.OpaqueType>;
+  isOptionalCallExpression<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.OptionalCallExpression>;
+  isOptionalIndexedAccessType<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.OptionalIndexedAccessType>;
+  isOptionalMemberExpression<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.OptionalMemberExpression>;
+  isParenthesizedExpression<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.ParenthesizedExpression>;
+  isPattern<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.Pattern>;
+  isPatternLike<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.PatternLike>;
+  isPipelineBareFunction<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.PipelineBareFunction>;
+  isPipelinePrimaryTopicReference<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.PipelinePrimaryTopicReference>;
+  isPipelineTopicExpression<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.PipelineTopicExpression>;
+  isPlaceholder<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.Placeholder>;
+  isPrivate<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.Private>;
+  isPrivateName<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.PrivateName>;
+  isProgram<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.Program>;
+  isProperty<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.Property>;
+  isPureish<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.Pureish>;
+  isQualifiedTypeIdentifier<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.QualifiedTypeIdentifier>;
+  isRecordExpression<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.RecordExpression>;
+  isRegExpLiteral<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.RegExpLiteral>;
+  isRegexLiteral<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.RegexLiteral>;
+  isRestElement<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.RestElement>;
+  isRestProperty<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.RestProperty>;
+  isReturnStatement<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.ReturnStatement>;
+  isScopable<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.Scopable>;
+  isSequenceExpression<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.SequenceExpression>;
+  isSpreadElement<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.SpreadElement>;
+  isSpreadProperty<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.SpreadProperty>;
+  isStandardized<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.Standardized>;
+  isStatement<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.Statement>;
+  isStaticBlock<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.StaticBlock>;
+  isStringLiteral<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.StringLiteral>;
+  isStringLiteralTypeAnnotation<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.StringLiteralTypeAnnotation>;
+  isStringTypeAnnotation<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.StringTypeAnnotation>;
+  isSuper<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.Super>;
+  isSwitchCase<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.SwitchCase>;
+  isSwitchStatement<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.SwitchStatement>;
+  isSymbolTypeAnnotation<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.SymbolTypeAnnotation>;
+  isTSAnyKeyword<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TSAnyKeyword>;
+  isTSArrayType<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TSArrayType>;
+  isTSAsExpression<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TSAsExpression>;
+  isTSBaseType<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TSBaseType>;
+  isTSBigIntKeyword<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TSBigIntKeyword>;
+  isTSBooleanKeyword<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TSBooleanKeyword>;
+  isTSCallSignatureDeclaration<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TSCallSignatureDeclaration>;
+  isTSConditionalType<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TSConditionalType>;
+  isTSConstructSignatureDeclaration<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TSConstructSignatureDeclaration>;
+  isTSConstructorType<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TSConstructorType>;
+  isTSDeclareFunction<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TSDeclareFunction>;
+  isTSDeclareMethod<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TSDeclareMethod>;
+  isTSEntityName<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TSEntityName>;
+  isTSEnumDeclaration<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TSEnumDeclaration>;
+  isTSEnumMember<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TSEnumMember>;
+  isTSExportAssignment<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TSExportAssignment>;
+  isTSExpressionWithTypeArguments<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TSExpressionWithTypeArguments>;
+  isTSExternalModuleReference<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TSExternalModuleReference>;
+  isTSFunctionType<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TSFunctionType>;
+  isTSImportEqualsDeclaration<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TSImportEqualsDeclaration>;
+  isTSImportType<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TSImportType>;
+  isTSIndexSignature<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TSIndexSignature>;
+  isTSIndexedAccessType<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TSIndexedAccessType>;
+  isTSInferType<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TSInferType>;
+  isTSInstantiationExpression<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TSInstantiationExpression>;
+  isTSInterfaceBody<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TSInterfaceBody>;
+  isTSInterfaceDeclaration<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TSInterfaceDeclaration>;
+  isTSIntersectionType<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TSIntersectionType>;
+  isTSIntrinsicKeyword<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TSIntrinsicKeyword>;
+  isTSLiteralType<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TSLiteralType>;
+  isTSMappedType<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TSMappedType>;
+  isTSMethodSignature<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TSMethodSignature>;
+  isTSModuleBlock<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TSModuleBlock>;
+  isTSModuleDeclaration<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TSModuleDeclaration>;
+  isTSNamedTupleMember<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TSNamedTupleMember>;
+  isTSNamespaceExportDeclaration<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TSNamespaceExportDeclaration>;
+  isTSNeverKeyword<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TSNeverKeyword>;
+  isTSNonNullExpression<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TSNonNullExpression>;
+  isTSNullKeyword<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TSNullKeyword>;
+  isTSNumberKeyword<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TSNumberKeyword>;
+  isTSObjectKeyword<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TSObjectKeyword>;
+  isTSOptionalType<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TSOptionalType>;
+  isTSParameterProperty<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TSParameterProperty>;
+  isTSParenthesizedType<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TSParenthesizedType>;
+  isTSPropertySignature<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TSPropertySignature>;
+  isTSQualifiedName<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TSQualifiedName>;
+  isTSRestType<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TSRestType>;
+  isTSStringKeyword<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TSStringKeyword>;
+  isTSSymbolKeyword<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TSSymbolKeyword>;
+  isTSThisType<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TSThisType>;
+  isTSTupleType<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TSTupleType>;
+  isTSType<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TSType>;
+  isTSTypeAliasDeclaration<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TSTypeAliasDeclaration>;
+  isTSTypeAnnotation<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TSTypeAnnotation>;
+  isTSTypeAssertion<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TSTypeAssertion>;
+  isTSTypeElement<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TSTypeElement>;
+  isTSTypeLiteral<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TSTypeLiteral>;
+  isTSTypeOperator<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TSTypeOperator>;
+  isTSTypeParameter<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TSTypeParameter>;
+  isTSTypeParameterDeclaration<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TSTypeParameterDeclaration>;
+  isTSTypeParameterInstantiation<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TSTypeParameterInstantiation>;
+  isTSTypePredicate<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TSTypePredicate>;
+  isTSTypeQuery<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TSTypeQuery>;
+  isTSTypeReference<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TSTypeReference>;
+  isTSUndefinedKeyword<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TSUndefinedKeyword>;
+  isTSUnionType<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TSUnionType>;
+  isTSUnknownKeyword<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TSUnknownKeyword>;
+  isTSVoidKeyword<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TSVoidKeyword>;
+  isTaggedTemplateExpression<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TaggedTemplateExpression>;
+  isTemplateElement<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TemplateElement>;
+  isTemplateLiteral<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TemplateLiteral>;
+  isTerminatorless<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.Terminatorless>;
+  isThisExpression<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.ThisExpression>;
+  isThisTypeAnnotation<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.ThisTypeAnnotation>;
+  isThrowStatement<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.ThrowStatement>;
+  isTopicReference<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TopicReference>;
+  isTryStatement<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TryStatement>;
+  isTupleExpression<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TupleExpression>;
+  isTupleTypeAnnotation<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TupleTypeAnnotation>;
+  isTypeAlias<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TypeAlias>;
+  isTypeAnnotation<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TypeAnnotation>;
+  isTypeCastExpression<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TypeCastExpression>;
+  isTypeParameter<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TypeParameter>;
+  isTypeParameterDeclaration<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TypeParameterDeclaration>;
+  isTypeParameterInstantiation<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TypeParameterInstantiation>;
+  isTypeScript<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TypeScript>;
+  isTypeofTypeAnnotation<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.TypeofTypeAnnotation>;
+  isUnaryExpression<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.UnaryExpression>;
+  isUnaryLike<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.UnaryLike>;
+  isUnionTypeAnnotation<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.UnionTypeAnnotation>;
+  isUpdateExpression<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.UpdateExpression>;
+  isUserWhitespacable<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.UserWhitespacable>;
+  isV8IntrinsicIdentifier<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.V8IntrinsicIdentifier>;
+  isVariableDeclaration<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.VariableDeclaration>;
+  isVariableDeclarator<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.VariableDeclarator>;
+  isVariance<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.Variance>;
+  isVoidTypeAnnotation<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.VoidTypeAnnotation>;
+  isWhile<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.While>;
+  isWhileStatement<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.WhileStatement>;
+  isWithStatement<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.WithStatement>;
+  isYieldExpression<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.YieldExpression>;
+  isBindingIdentifier<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & VirtualTypeAliases["BindingIdentifier"]>;
   isBlockScoped(opts?: object): boolean;
-  isExistentialTypeParam(
+  isExistentialTypeParam<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & VirtualTypeAliases["ExistentialTypeParam"]>;
+  isExpression<T extends t.Node>(
+    this: NodePath<T>,
     opts?: object,
-  ): this is NodePath<VirtualTypeAliases["ExistentialTypeParam"]>;
-  isExpression(opts?: object): this is NodePath<t.Expression>;
-  isFlow(opts?: object): this is NodePath<t.Flow>;
-  isForAwaitStatement(
+  ): this is NodePath<T & t.Expression>;
+  isFlow<T extends t.Node>(
+    this: NodePath<T>,
     opts?: object,
-  ): this is NodePath<VirtualTypeAliases["ForAwaitStatement"]>;
+  ): this is NodePath<T & t.Flow>;
+  isForAwaitStatement<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & VirtualTypeAliases["ForAwaitStatement"]>;
   isGenerated(opts?: object): boolean;
-  isNumericLiteralTypeAnnotation(
+  isNumericLiteralTypeAnnotation<T extends t.Node>(
+    this: NodePath<T>,
     opts?: object,
-  ): this is NodePath<VirtualTypeAliases["NumericLiteralTypeAnnotation"]>;
+  ): this is NodePath<T & VirtualTypeAliases["NumericLiteralTypeAnnotation"]>;
   isPure(constantsOnly?: boolean): boolean;
   isReferenced(opts?: object): boolean;
-  isReferencedIdentifier(
+  isReferencedIdentifier<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & VirtualTypeAliases["ReferencedIdentifier"]>;
+  isReferencedMemberExpression<T extends t.Node>(
+    this: NodePath<T>,
     opts?: object,
-  ): this is NodePath<VirtualTypeAliases["ReferencedIdentifier"]>;
-  isReferencedMemberExpression(
+  ): this is NodePath<T & VirtualTypeAliases["ReferencedMemberExpression"]>;
+  isRestProperty<T extends t.Node>(
+    this: NodePath<T>,
     opts?: object,
-  ): this is NodePath<VirtualTypeAliases["ReferencedMemberExpression"]>;
-  isRestProperty(
+  ): this is NodePath<T & VirtualTypeAliases["RestProperty"]>;
+  isScope<T extends t.Node>(
+    this: NodePath<T>,
     opts?: object,
-  ): this is NodePath<VirtualTypeAliases["RestProperty"]>;
-  isScope(opts?: object): this is NodePath<VirtualTypeAliases["Scope"]>;
-  isSpreadProperty(
+  ): this is NodePath<T & VirtualTypeAliases["Scope"]>;
+  isSpreadProperty<T extends t.Node>(
+    this: NodePath<T>,
     opts?: object,
-  ): this is NodePath<VirtualTypeAliases["SpreadProperty"]>;
-  isStatement(opts?: object): this is NodePath<t.Statement>;
+  ): this is NodePath<T & VirtualTypeAliases["SpreadProperty"]>;
+  isStatement<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & t.Statement>;
   isUser(opts?: object): boolean;
-  isVar(opts?: object): this is NodePath<VirtualTypeAliases["Var"]>;
+  isVar<T extends t.Node>(
+    this: NodePath<T>,
+    opts?: object,
+  ): this is NodePath<T & VirtualTypeAliases["Var"]>;
 }
diff --git a/packages/babel-traverse/src/path/index.ts b/packages/babel-traverse/src/path/index.ts
index 7a537612bbfa..faa5af2c55bc 100644
--- a/packages/babel-traverse/src/path/index.ts
+++ b/packages/babel-traverse/src/path/index.ts
@@ -272,7 +272,7 @@ for (const type of Object.keys(virtualTypes) as (keyof typeof virtualTypes)[]) {
 
   const virtualType = virtualTypes[type];
 
-  NodePath.prototype[`is${type}`] = function (opts) {
+  NodePath.prototype[`is${type}`] = function (opts?: any) {
     // @ts-expect-error checkPath will throw when type is ExistentialTypeParam/NumericLiteralTypeAnnotation
     return virtualType.checkPath(this, opts);
   };
diff --git a/packages/babel-traverse/src/path/introspection.ts b/packages/babel-traverse/src/path/introspection.ts
index cfe31bc76a9a..9a44718c387e 100644
--- a/packages/babel-traverse/src/path/introspection.ts
+++ b/packages/babel-traverse/src/path/introspection.ts
@@ -645,8 +645,6 @@ export function isInStrictMode(this: NodePath) {
 
     if (path.isClass()) return true;
 
-    if (!path.isProgram() && !path.isFunction()) return false;
-
     if (
       path.isArrowFunctionExpression() &&
       !path.get("body").isBlockStatement()
@@ -654,9 +652,14 @@ export function isInStrictMode(this: NodePath) {
       return false;
     }
 
-    const body: t.BlockStatement | t.Program = path.isFunction()
-      ? (path.node.body as t.BlockStatement)
-      : (path.node as t.Program);
+    let body: t.BlockStatement | t.Program;
+    if (path.isFunction()) {
+      body = path.node.body as t.BlockStatement;
+    } else if (path.isProgram()) {
+      body = path.node;
+    } else {
+      return false;
+    }
 
     for (const directive of body.directives) {
       if (directive.value.value === "use strict") {