diff --git a/packages/babel-traverse/scripts/generators/asserts.js b/packages/babel-traverse/scripts/generators/asserts.js
index 5913aaae0060..c93efbb4173b 100644
--- a/packages/babel-traverse/scripts/generators/asserts.js
+++ b/packages/babel-traverse/scripts/generators/asserts.js
@@ -8,13 +8,20 @@ export default function generateAsserts() {
 import type * as t from "@babel/types";
 import type NodePath from "../index";
 
+type Opts<Obj> = Partial<{
+  [Prop in keyof Obj]: Obj[Prop] extends t.Node
+    ? t.Node
+    : Obj[Prop] extends t.Node[]
+    ? t.Node[]
+    : Obj[Prop];
+}>;
 
 export interface NodePathAssertions {`;
 
   for (const type of [...t.TYPES].sort()) {
     output += `
   assert${type}(
-    opts?: object,
+    opts?: Opts<t.${type}>,
   ): asserts this is NodePath<t.${type}>;`;
   }
 
diff --git a/packages/babel-traverse/scripts/generators/validators.js b/packages/babel-traverse/scripts/generators/validators.js
index 50340de31f33..8f197c6c6577 100644
--- a/packages/babel-traverse/scripts/generators/validators.js
+++ b/packages/babel-traverse/scripts/generators/validators.js
@@ -9,18 +9,27 @@ import type * as t from "@babel/types";
 import type NodePath from "../index";
 import type { VirtualTypeNodePathValidators } from "../lib/virtual-types-validator";
 
+type Opts<Obj> = Partial<{
+  [Prop in keyof Obj]: Obj[Prop] extends t.Node
+    ? t.Node
+    : Obj[Prop] extends t.Node[]
+    ? t.Node[]
+    : Obj[Prop];
+}>;
+
 interface BaseNodePathValidators {
 `;
 
   for (const type of [...t.TYPES].sort()) {
-    output += `is${type}<T extends t.Node>(this: NodePath<T>, opts?: object): this is NodePath<T & t.${type}>;`;
+    output += `is${type}<T extends t.Node>(this: NodePath<T>, opts?: Opts<t.${type}>): this is NodePath<T & t.${type}>;`;
   }
 
   output += `
 }
 
 export interface NodePathValidators
-  extends BaseNodePathValidators, VirtualTypeNodePathValidators {}
+  extends Omit<BaseNodePathValidators, keyof VirtualTypeNodePathValidators>,
+    VirtualTypeNodePathValidators {}
 `;
 
   return output;
diff --git a/packages/babel-traverse/src/path/generated/asserts.d.ts b/packages/babel-traverse/src/path/generated/asserts.d.ts
index 6b974533d294..24c21fbfdfeb 100644
--- a/packages/babel-traverse/src/path/generated/asserts.d.ts
+++ b/packages/babel-traverse/src/path/generated/asserts.d.ts
@@ -5,712 +5,866 @@
 import type * as t from "@babel/types";
 import type NodePath from "../index";
 
+type Opts<Obj> = Partial<{
+  [Prop in keyof Obj]: Obj[Prop] extends t.Node
+    ? t.Node
+    : Obj[Prop] extends t.Node[]
+    ? t.Node[]
+    : Obj[Prop];
+}>;
+
 export interface NodePathAssertions {
-  assertAccessor(opts?: object): asserts this is NodePath<t.Accessor>;
+  assertAccessor(opts?: Opts<t.Accessor>): asserts this is NodePath<t.Accessor>;
   assertAnyTypeAnnotation(
-    opts?: object,
+    opts?: Opts<t.AnyTypeAnnotation>,
   ): asserts this is NodePath<t.AnyTypeAnnotation>;
   assertArgumentPlaceholder(
-    opts?: object,
+    opts?: Opts<t.ArgumentPlaceholder>,
   ): asserts this is NodePath<t.ArgumentPlaceholder>;
   assertArrayExpression(
-    opts?: object,
+    opts?: Opts<t.ArrayExpression>,
   ): asserts this is NodePath<t.ArrayExpression>;
-  assertArrayPattern(opts?: object): asserts this is NodePath<t.ArrayPattern>;
+  assertArrayPattern(
+    opts?: Opts<t.ArrayPattern>,
+  ): asserts this is NodePath<t.ArrayPattern>;
   assertArrayTypeAnnotation(
-    opts?: object,
+    opts?: Opts<t.ArrayTypeAnnotation>,
   ): asserts this is NodePath<t.ArrayTypeAnnotation>;
   assertArrowFunctionExpression(
-    opts?: object,
+    opts?: Opts<t.ArrowFunctionExpression>,
   ): asserts this is NodePath<t.ArrowFunctionExpression>;
   assertAssignmentExpression(
-    opts?: object,
+    opts?: Opts<t.AssignmentExpression>,
   ): asserts this is NodePath<t.AssignmentExpression>;
   assertAssignmentPattern(
-    opts?: object,
+    opts?: Opts<t.AssignmentPattern>,
   ): asserts this is NodePath<t.AssignmentPattern>;
   assertAwaitExpression(
-    opts?: object,
+    opts?: Opts<t.AwaitExpression>,
   ): asserts this is NodePath<t.AwaitExpression>;
-  assertBigIntLiteral(opts?: object): asserts this is NodePath<t.BigIntLiteral>;
-  assertBinary(opts?: object): asserts this is NodePath<t.Binary>;
+  assertBigIntLiteral(
+    opts?: Opts<t.BigIntLiteral>,
+  ): asserts this is NodePath<t.BigIntLiteral>;
+  assertBinary(opts?: Opts<t.Binary>): asserts this is NodePath<t.Binary>;
   assertBinaryExpression(
-    opts?: object,
+    opts?: Opts<t.BinaryExpression>,
   ): asserts this is NodePath<t.BinaryExpression>;
   assertBindExpression(
-    opts?: object,
+    opts?: Opts<t.BindExpression>,
   ): asserts this is NodePath<t.BindExpression>;
-  assertBlock(opts?: object): asserts this is NodePath<t.Block>;
-  assertBlockParent(opts?: object): asserts this is NodePath<t.BlockParent>;
+  assertBlock(opts?: Opts<t.Block>): asserts this is NodePath<t.Block>;
+  assertBlockParent(
+    opts?: Opts<t.BlockParent>,
+  ): asserts this is NodePath<t.BlockParent>;
   assertBlockStatement(
-    opts?: object,
+    opts?: Opts<t.BlockStatement>,
   ): asserts this is NodePath<t.BlockStatement>;
   assertBooleanLiteral(
-    opts?: object,
+    opts?: Opts<t.BooleanLiteral>,
   ): asserts this is NodePath<t.BooleanLiteral>;
   assertBooleanLiteralTypeAnnotation(
-    opts?: object,
+    opts?: Opts<t.BooleanLiteralTypeAnnotation>,
   ): asserts this is NodePath<t.BooleanLiteralTypeAnnotation>;
   assertBooleanTypeAnnotation(
-    opts?: object,
+    opts?: Opts<t.BooleanTypeAnnotation>,
   ): asserts this is NodePath<t.BooleanTypeAnnotation>;
   assertBreakStatement(
-    opts?: object,
+    opts?: Opts<t.BreakStatement>,
   ): asserts this is NodePath<t.BreakStatement>;
   assertCallExpression(
-    opts?: object,
+    opts?: Opts<t.CallExpression>,
   ): asserts this is NodePath<t.CallExpression>;
-  assertCatchClause(opts?: object): asserts this is NodePath<t.CatchClause>;
-  assertClass(opts?: object): asserts this is NodePath<t.Class>;
+  assertCatchClause(
+    opts?: Opts<t.CatchClause>,
+  ): asserts this is NodePath<t.CatchClause>;
+  assertClass(opts?: Opts<t.Class>): asserts this is NodePath<t.Class>;
   assertClassAccessorProperty(
-    opts?: object,
+    opts?: Opts<t.ClassAccessorProperty>,
   ): asserts this is NodePath<t.ClassAccessorProperty>;
-  assertClassBody(opts?: object): asserts this is NodePath<t.ClassBody>;
+  assertClassBody(
+    opts?: Opts<t.ClassBody>,
+  ): asserts this is NodePath<t.ClassBody>;
   assertClassDeclaration(
-    opts?: object,
+    opts?: Opts<t.ClassDeclaration>,
   ): asserts this is NodePath<t.ClassDeclaration>;
   assertClassExpression(
-    opts?: object,
+    opts?: Opts<t.ClassExpression>,
   ): asserts this is NodePath<t.ClassExpression>;
   assertClassImplements(
-    opts?: object,
+    opts?: Opts<t.ClassImplements>,
   ): asserts this is NodePath<t.ClassImplements>;
-  assertClassMethod(opts?: object): asserts this is NodePath<t.ClassMethod>;
+  assertClassMethod(
+    opts?: Opts<t.ClassMethod>,
+  ): asserts this is NodePath<t.ClassMethod>;
   assertClassPrivateMethod(
-    opts?: object,
+    opts?: Opts<t.ClassPrivateMethod>,
   ): asserts this is NodePath<t.ClassPrivateMethod>;
   assertClassPrivateProperty(
-    opts?: object,
+    opts?: Opts<t.ClassPrivateProperty>,
   ): asserts this is NodePath<t.ClassPrivateProperty>;
-  assertClassProperty(opts?: object): asserts this is NodePath<t.ClassProperty>;
+  assertClassProperty(
+    opts?: Opts<t.ClassProperty>,
+  ): asserts this is NodePath<t.ClassProperty>;
   assertCompletionStatement(
-    opts?: object,
+    opts?: Opts<t.CompletionStatement>,
   ): asserts this is NodePath<t.CompletionStatement>;
-  assertConditional(opts?: object): asserts this is NodePath<t.Conditional>;
+  assertConditional(
+    opts?: Opts<t.Conditional>,
+  ): asserts this is NodePath<t.Conditional>;
   assertConditionalExpression(
-    opts?: object,
+    opts?: Opts<t.ConditionalExpression>,
   ): asserts this is NodePath<t.ConditionalExpression>;
   assertContinueStatement(
-    opts?: object,
+    opts?: Opts<t.ContinueStatement>,
   ): asserts this is NodePath<t.ContinueStatement>;
   assertDebuggerStatement(
-    opts?: object,
+    opts?: Opts<t.DebuggerStatement>,
   ): asserts this is NodePath<t.DebuggerStatement>;
   assertDecimalLiteral(
-    opts?: object,
+    opts?: Opts<t.DecimalLiteral>,
   ): asserts this is NodePath<t.DecimalLiteral>;
-  assertDeclaration(opts?: object): asserts this is NodePath<t.Declaration>;
-  assertDeclareClass(opts?: object): asserts this is NodePath<t.DeclareClass>;
+  assertDeclaration(
+    opts?: Opts<t.Declaration>,
+  ): asserts this is NodePath<t.Declaration>;
+  assertDeclareClass(
+    opts?: Opts<t.DeclareClass>,
+  ): asserts this is NodePath<t.DeclareClass>;
   assertDeclareExportAllDeclaration(
-    opts?: object,
+    opts?: Opts<t.DeclareExportAllDeclaration>,
   ): asserts this is NodePath<t.DeclareExportAllDeclaration>;
   assertDeclareExportDeclaration(
-    opts?: object,
+    opts?: Opts<t.DeclareExportDeclaration>,
   ): asserts this is NodePath<t.DeclareExportDeclaration>;
   assertDeclareFunction(
-    opts?: object,
+    opts?: Opts<t.DeclareFunction>,
   ): asserts this is NodePath<t.DeclareFunction>;
   assertDeclareInterface(
-    opts?: object,
+    opts?: Opts<t.DeclareInterface>,
   ): asserts this is NodePath<t.DeclareInterface>;
-  assertDeclareModule(opts?: object): asserts this is NodePath<t.DeclareModule>;
+  assertDeclareModule(
+    opts?: Opts<t.DeclareModule>,
+  ): asserts this is NodePath<t.DeclareModule>;
   assertDeclareModuleExports(
-    opts?: object,
+    opts?: Opts<t.DeclareModuleExports>,
   ): asserts this is NodePath<t.DeclareModuleExports>;
   assertDeclareOpaqueType(
-    opts?: object,
+    opts?: Opts<t.DeclareOpaqueType>,
   ): asserts this is NodePath<t.DeclareOpaqueType>;
   assertDeclareTypeAlias(
-    opts?: object,
+    opts?: Opts<t.DeclareTypeAlias>,
   ): asserts this is NodePath<t.DeclareTypeAlias>;
   assertDeclareVariable(
-    opts?: object,
+    opts?: Opts<t.DeclareVariable>,
   ): asserts this is NodePath<t.DeclareVariable>;
   assertDeclaredPredicate(
-    opts?: object,
+    opts?: Opts<t.DeclaredPredicate>,
   ): asserts this is NodePath<t.DeclaredPredicate>;
-  assertDecorator(opts?: object): asserts this is NodePath<t.Decorator>;
-  assertDirective(opts?: object): asserts this is NodePath<t.Directive>;
+  assertDecorator(
+    opts?: Opts<t.Decorator>,
+  ): asserts this is NodePath<t.Decorator>;
+  assertDirective(
+    opts?: Opts<t.Directive>,
+  ): asserts this is NodePath<t.Directive>;
   assertDirectiveLiteral(
-    opts?: object,
+    opts?: Opts<t.DirectiveLiteral>,
   ): asserts this is NodePath<t.DirectiveLiteral>;
-  assertDoExpression(opts?: object): asserts this is NodePath<t.DoExpression>;
+  assertDoExpression(
+    opts?: Opts<t.DoExpression>,
+  ): asserts this is NodePath<t.DoExpression>;
   assertDoWhileStatement(
-    opts?: object,
+    opts?: Opts<t.DoWhileStatement>,
   ): asserts this is NodePath<t.DoWhileStatement>;
   assertEmptyStatement(
-    opts?: object,
+    opts?: Opts<t.EmptyStatement>,
   ): asserts this is NodePath<t.EmptyStatement>;
   assertEmptyTypeAnnotation(
-    opts?: object,
+    opts?: Opts<t.EmptyTypeAnnotation>,
   ): asserts this is NodePath<t.EmptyTypeAnnotation>;
-  assertEnumBody(opts?: object): asserts this is NodePath<t.EnumBody>;
+  assertEnumBody(opts?: Opts<t.EnumBody>): asserts this is NodePath<t.EnumBody>;
   assertEnumBooleanBody(
-    opts?: object,
+    opts?: Opts<t.EnumBooleanBody>,
   ): asserts this is NodePath<t.EnumBooleanBody>;
   assertEnumBooleanMember(
-    opts?: object,
+    opts?: Opts<t.EnumBooleanMember>,
   ): asserts this is NodePath<t.EnumBooleanMember>;
   assertEnumDeclaration(
-    opts?: object,
+    opts?: Opts<t.EnumDeclaration>,
   ): asserts this is NodePath<t.EnumDeclaration>;
   assertEnumDefaultedMember(
-    opts?: object,
+    opts?: Opts<t.EnumDefaultedMember>,
   ): asserts this is NodePath<t.EnumDefaultedMember>;
-  assertEnumMember(opts?: object): asserts this is NodePath<t.EnumMember>;
+  assertEnumMember(
+    opts?: Opts<t.EnumMember>,
+  ): asserts this is NodePath<t.EnumMember>;
   assertEnumNumberBody(
-    opts?: object,
+    opts?: Opts<t.EnumNumberBody>,
   ): asserts this is NodePath<t.EnumNumberBody>;
   assertEnumNumberMember(
-    opts?: object,
+    opts?: Opts<t.EnumNumberMember>,
   ): asserts this is NodePath<t.EnumNumberMember>;
   assertEnumStringBody(
-    opts?: object,
+    opts?: Opts<t.EnumStringBody>,
   ): asserts this is NodePath<t.EnumStringBody>;
   assertEnumStringMember(
-    opts?: object,
+    opts?: Opts<t.EnumStringMember>,
   ): asserts this is NodePath<t.EnumStringMember>;
   assertEnumSymbolBody(
-    opts?: object,
+    opts?: Opts<t.EnumSymbolBody>,
   ): asserts this is NodePath<t.EnumSymbolBody>;
   assertExistsTypeAnnotation(
-    opts?: object,
+    opts?: Opts<t.ExistsTypeAnnotation>,
   ): asserts this is NodePath<t.ExistsTypeAnnotation>;
   assertExportAllDeclaration(
-    opts?: object,
+    opts?: Opts<t.ExportAllDeclaration>,
   ): asserts this is NodePath<t.ExportAllDeclaration>;
   assertExportDeclaration(
-    opts?: object,
+    opts?: Opts<t.ExportDeclaration>,
   ): asserts this is NodePath<t.ExportDeclaration>;
   assertExportDefaultDeclaration(
-    opts?: object,
+    opts?: Opts<t.ExportDefaultDeclaration>,
   ): asserts this is NodePath<t.ExportDefaultDeclaration>;
   assertExportDefaultSpecifier(
-    opts?: object,
+    opts?: Opts<t.ExportDefaultSpecifier>,
   ): asserts this is NodePath<t.ExportDefaultSpecifier>;
   assertExportNamedDeclaration(
-    opts?: object,
+    opts?: Opts<t.ExportNamedDeclaration>,
   ): asserts this is NodePath<t.ExportNamedDeclaration>;
   assertExportNamespaceSpecifier(
-    opts?: object,
+    opts?: Opts<t.ExportNamespaceSpecifier>,
   ): asserts this is NodePath<t.ExportNamespaceSpecifier>;
   assertExportSpecifier(
-    opts?: object,
+    opts?: Opts<t.ExportSpecifier>,
   ): asserts this is NodePath<t.ExportSpecifier>;
-  assertExpression(opts?: object): asserts this is NodePath<t.Expression>;
+  assertExpression(
+    opts?: Opts<t.Expression>,
+  ): asserts this is NodePath<t.Expression>;
   assertExpressionStatement(
-    opts?: object,
+    opts?: Opts<t.ExpressionStatement>,
   ): asserts this is NodePath<t.ExpressionStatement>;
   assertExpressionWrapper(
-    opts?: object,
+    opts?: Opts<t.ExpressionWrapper>,
   ): asserts this is NodePath<t.ExpressionWrapper>;
-  assertFile(opts?: object): asserts this is NodePath<t.File>;
-  assertFlow(opts?: object): asserts this is NodePath<t.Flow>;
+  assertFile(opts?: Opts<t.File>): asserts this is NodePath<t.File>;
+  assertFlow(opts?: Opts<t.Flow>): asserts this is NodePath<t.Flow>;
   assertFlowBaseAnnotation(
-    opts?: object,
+    opts?: Opts<t.FlowBaseAnnotation>,
   ): asserts this is NodePath<t.FlowBaseAnnotation>;
   assertFlowDeclaration(
-    opts?: object,
+    opts?: Opts<t.FlowDeclaration>,
   ): asserts this is NodePath<t.FlowDeclaration>;
-  assertFlowPredicate(opts?: object): asserts this is NodePath<t.FlowPredicate>;
-  assertFlowType(opts?: object): asserts this is NodePath<t.FlowType>;
-  assertFor(opts?: object): asserts this is NodePath<t.For>;
+  assertFlowPredicate(
+    opts?: Opts<t.FlowPredicate>,
+  ): asserts this is NodePath<t.FlowPredicate>;
+  assertFlowType(opts?: Opts<t.FlowType>): asserts this is NodePath<t.FlowType>;
+  assertFor(opts?: Opts<t.For>): asserts this is NodePath<t.For>;
   assertForInStatement(
-    opts?: object,
+    opts?: Opts<t.ForInStatement>,
   ): asserts this is NodePath<t.ForInStatement>;
   assertForOfStatement(
-    opts?: object,
+    opts?: Opts<t.ForOfStatement>,
   ): asserts this is NodePath<t.ForOfStatement>;
-  assertForStatement(opts?: object): asserts this is NodePath<t.ForStatement>;
-  assertForXStatement(opts?: object): asserts this is NodePath<t.ForXStatement>;
-  assertFunction(opts?: object): asserts this is NodePath<t.Function>;
+  assertForStatement(
+    opts?: Opts<t.ForStatement>,
+  ): asserts this is NodePath<t.ForStatement>;
+  assertForXStatement(
+    opts?: Opts<t.ForXStatement>,
+  ): asserts this is NodePath<t.ForXStatement>;
+  assertFunction(opts?: Opts<t.Function>): asserts this is NodePath<t.Function>;
   assertFunctionDeclaration(
-    opts?: object,
+    opts?: Opts<t.FunctionDeclaration>,
   ): asserts this is NodePath<t.FunctionDeclaration>;
   assertFunctionExpression(
-    opts?: object,
+    opts?: Opts<t.FunctionExpression>,
   ): asserts this is NodePath<t.FunctionExpression>;
   assertFunctionParent(
-    opts?: object,
+    opts?: Opts<t.FunctionParent>,
   ): asserts this is NodePath<t.FunctionParent>;
   assertFunctionTypeAnnotation(
-    opts?: object,
+    opts?: Opts<t.FunctionTypeAnnotation>,
   ): asserts this is NodePath<t.FunctionTypeAnnotation>;
   assertFunctionTypeParam(
-    opts?: object,
+    opts?: Opts<t.FunctionTypeParam>,
   ): asserts this is NodePath<t.FunctionTypeParam>;
   assertGenericTypeAnnotation(
-    opts?: object,
+    opts?: Opts<t.GenericTypeAnnotation>,
   ): asserts this is NodePath<t.GenericTypeAnnotation>;
-  assertIdentifier(opts?: object): asserts this is NodePath<t.Identifier>;
-  assertIfStatement(opts?: object): asserts this is NodePath<t.IfStatement>;
-  assertImmutable(opts?: object): asserts this is NodePath<t.Immutable>;
-  assertImport(opts?: object): asserts this is NodePath<t.Import>;
+  assertIdentifier(
+    opts?: Opts<t.Identifier>,
+  ): asserts this is NodePath<t.Identifier>;
+  assertIfStatement(
+    opts?: Opts<t.IfStatement>,
+  ): asserts this is NodePath<t.IfStatement>;
+  assertImmutable(
+    opts?: Opts<t.Immutable>,
+  ): asserts this is NodePath<t.Immutable>;
+  assertImport(opts?: Opts<t.Import>): asserts this is NodePath<t.Import>;
   assertImportAttribute(
-    opts?: object,
+    opts?: Opts<t.ImportAttribute>,
   ): asserts this is NodePath<t.ImportAttribute>;
   assertImportDeclaration(
-    opts?: object,
+    opts?: Opts<t.ImportDeclaration>,
   ): asserts this is NodePath<t.ImportDeclaration>;
   assertImportDefaultSpecifier(
-    opts?: object,
+    opts?: Opts<t.ImportDefaultSpecifier>,
   ): asserts this is NodePath<t.ImportDefaultSpecifier>;
   assertImportNamespaceSpecifier(
-    opts?: object,
+    opts?: Opts<t.ImportNamespaceSpecifier>,
   ): asserts this is NodePath<t.ImportNamespaceSpecifier>;
   assertImportOrExportDeclaration(
-    opts?: object,
+    opts?: Opts<t.ImportOrExportDeclaration>,
   ): asserts this is NodePath<t.ImportOrExportDeclaration>;
   assertImportSpecifier(
-    opts?: object,
+    opts?: Opts<t.ImportSpecifier>,
   ): asserts this is NodePath<t.ImportSpecifier>;
   assertIndexedAccessType(
-    opts?: object,
+    opts?: Opts<t.IndexedAccessType>,
   ): asserts this is NodePath<t.IndexedAccessType>;
   assertInferredPredicate(
-    opts?: object,
+    opts?: Opts<t.InferredPredicate>,
   ): asserts this is NodePath<t.InferredPredicate>;
   assertInterfaceDeclaration(
-    opts?: object,
+    opts?: Opts<t.InterfaceDeclaration>,
   ): asserts this is NodePath<t.InterfaceDeclaration>;
   assertInterfaceExtends(
-    opts?: object,
+    opts?: Opts<t.InterfaceExtends>,
   ): asserts this is NodePath<t.InterfaceExtends>;
   assertInterfaceTypeAnnotation(
-    opts?: object,
+    opts?: Opts<t.InterfaceTypeAnnotation>,
   ): asserts this is NodePath<t.InterfaceTypeAnnotation>;
   assertInterpreterDirective(
-    opts?: object,
+    opts?: Opts<t.InterpreterDirective>,
   ): asserts this is NodePath<t.InterpreterDirective>;
   assertIntersectionTypeAnnotation(
-    opts?: object,
+    opts?: Opts<t.IntersectionTypeAnnotation>,
   ): asserts this is NodePath<t.IntersectionTypeAnnotation>;
-  assertJSX(opts?: object): asserts this is NodePath<t.JSX>;
-  assertJSXAttribute(opts?: object): asserts this is NodePath<t.JSXAttribute>;
+  assertJSX(opts?: Opts<t.JSX>): asserts this is NodePath<t.JSX>;
+  assertJSXAttribute(
+    opts?: Opts<t.JSXAttribute>,
+  ): asserts this is NodePath<t.JSXAttribute>;
   assertJSXClosingElement(
-    opts?: object,
+    opts?: Opts<t.JSXClosingElement>,
   ): asserts this is NodePath<t.JSXClosingElement>;
   assertJSXClosingFragment(
-    opts?: object,
+    opts?: Opts<t.JSXClosingFragment>,
   ): asserts this is NodePath<t.JSXClosingFragment>;
-  assertJSXElement(opts?: object): asserts this is NodePath<t.JSXElement>;
+  assertJSXElement(
+    opts?: Opts<t.JSXElement>,
+  ): asserts this is NodePath<t.JSXElement>;
   assertJSXEmptyExpression(
-    opts?: object,
+    opts?: Opts<t.JSXEmptyExpression>,
   ): asserts this is NodePath<t.JSXEmptyExpression>;
   assertJSXExpressionContainer(
-    opts?: object,
+    opts?: Opts<t.JSXExpressionContainer>,
   ): asserts this is NodePath<t.JSXExpressionContainer>;
-  assertJSXFragment(opts?: object): asserts this is NodePath<t.JSXFragment>;
-  assertJSXIdentifier(opts?: object): asserts this is NodePath<t.JSXIdentifier>;
+  assertJSXFragment(
+    opts?: Opts<t.JSXFragment>,
+  ): asserts this is NodePath<t.JSXFragment>;
+  assertJSXIdentifier(
+    opts?: Opts<t.JSXIdentifier>,
+  ): asserts this is NodePath<t.JSXIdentifier>;
   assertJSXMemberExpression(
-    opts?: object,
+    opts?: Opts<t.JSXMemberExpression>,
   ): asserts this is NodePath<t.JSXMemberExpression>;
   assertJSXNamespacedName(
-    opts?: object,
+    opts?: Opts<t.JSXNamespacedName>,
   ): asserts this is NodePath<t.JSXNamespacedName>;
   assertJSXOpeningElement(
-    opts?: object,
+    opts?: Opts<t.JSXOpeningElement>,
   ): asserts this is NodePath<t.JSXOpeningElement>;
   assertJSXOpeningFragment(
-    opts?: object,
+    opts?: Opts<t.JSXOpeningFragment>,
   ): asserts this is NodePath<t.JSXOpeningFragment>;
   assertJSXSpreadAttribute(
-    opts?: object,
+    opts?: Opts<t.JSXSpreadAttribute>,
   ): asserts this is NodePath<t.JSXSpreadAttribute>;
   assertJSXSpreadChild(
-    opts?: object,
+    opts?: Opts<t.JSXSpreadChild>,
   ): asserts this is NodePath<t.JSXSpreadChild>;
-  assertJSXText(opts?: object): asserts this is NodePath<t.JSXText>;
-  assertLVal(opts?: object): asserts this is NodePath<t.LVal>;
+  assertJSXText(opts?: Opts<t.JSXText>): asserts this is NodePath<t.JSXText>;
+  assertLVal(opts?: Opts<t.LVal>): asserts this is NodePath<t.LVal>;
   assertLabeledStatement(
-    opts?: object,
+    opts?: Opts<t.LabeledStatement>,
   ): asserts this is NodePath<t.LabeledStatement>;
-  assertLiteral(opts?: object): asserts this is NodePath<t.Literal>;
+  assertLiteral(opts?: Opts<t.Literal>): asserts this is NodePath<t.Literal>;
   assertLogicalExpression(
-    opts?: object,
+    opts?: Opts<t.LogicalExpression>,
   ): asserts this is NodePath<t.LogicalExpression>;
-  assertLoop(opts?: object): asserts this is NodePath<t.Loop>;
+  assertLoop(opts?: Opts<t.Loop>): asserts this is NodePath<t.Loop>;
   assertMemberExpression(
-    opts?: object,
+    opts?: Opts<t.MemberExpression>,
   ): asserts this is NodePath<t.MemberExpression>;
-  assertMetaProperty(opts?: object): asserts this is NodePath<t.MetaProperty>;
-  assertMethod(opts?: object): asserts this is NodePath<t.Method>;
-  assertMiscellaneous(opts?: object): asserts this is NodePath<t.Miscellaneous>;
+  assertMetaProperty(
+    opts?: Opts<t.MetaProperty>,
+  ): asserts this is NodePath<t.MetaProperty>;
+  assertMethod(opts?: Opts<t.Method>): asserts this is NodePath<t.Method>;
+  assertMiscellaneous(
+    opts?: Opts<t.Miscellaneous>,
+  ): asserts this is NodePath<t.Miscellaneous>;
   assertMixedTypeAnnotation(
-    opts?: object,
+    opts?: Opts<t.MixedTypeAnnotation>,
   ): asserts this is NodePath<t.MixedTypeAnnotation>;
   assertModuleDeclaration(
-    opts?: object,
+    opts?: Opts<t.ModuleDeclaration>,
   ): asserts this is NodePath<t.ModuleDeclaration>;
   assertModuleExpression(
-    opts?: object,
+    opts?: Opts<t.ModuleExpression>,
   ): asserts this is NodePath<t.ModuleExpression>;
   assertModuleSpecifier(
-    opts?: object,
+    opts?: Opts<t.ModuleSpecifier>,
   ): asserts this is NodePath<t.ModuleSpecifier>;
-  assertNewExpression(opts?: object): asserts this is NodePath<t.NewExpression>;
-  assertNoop(opts?: object): asserts this is NodePath<t.Noop>;
-  assertNullLiteral(opts?: object): asserts this is NodePath<t.NullLiteral>;
+  assertNewExpression(
+    opts?: Opts<t.NewExpression>,
+  ): asserts this is NodePath<t.NewExpression>;
+  assertNoop(opts?: Opts<t.Noop>): asserts this is NodePath<t.Noop>;
+  assertNullLiteral(
+    opts?: Opts<t.NullLiteral>,
+  ): asserts this is NodePath<t.NullLiteral>;
   assertNullLiteralTypeAnnotation(
-    opts?: object,
+    opts?: Opts<t.NullLiteralTypeAnnotation>,
   ): asserts this is NodePath<t.NullLiteralTypeAnnotation>;
   assertNullableTypeAnnotation(
-    opts?: object,
+    opts?: Opts<t.NullableTypeAnnotation>,
   ): asserts this is NodePath<t.NullableTypeAnnotation>;
-  assertNumberLiteral(opts?: object): asserts this is NodePath<t.NumberLiteral>;
+  assertNumberLiteral(
+    opts?: Opts<t.NumberLiteral>,
+  ): asserts this is NodePath<t.NumberLiteral>;
   assertNumberLiteralTypeAnnotation(
-    opts?: object,
+    opts?: Opts<t.NumberLiteralTypeAnnotation>,
   ): asserts this is NodePath<t.NumberLiteralTypeAnnotation>;
   assertNumberTypeAnnotation(
-    opts?: object,
+    opts?: Opts<t.NumberTypeAnnotation>,
   ): asserts this is NodePath<t.NumberTypeAnnotation>;
   assertNumericLiteral(
-    opts?: object,
+    opts?: Opts<t.NumericLiteral>,
   ): asserts this is NodePath<t.NumericLiteral>;
   assertObjectExpression(
-    opts?: object,
+    opts?: Opts<t.ObjectExpression>,
   ): asserts this is NodePath<t.ObjectExpression>;
-  assertObjectMember(opts?: object): asserts this is NodePath<t.ObjectMember>;
-  assertObjectMethod(opts?: object): asserts this is NodePath<t.ObjectMethod>;
-  assertObjectPattern(opts?: object): asserts this is NodePath<t.ObjectPattern>;
+  assertObjectMember(
+    opts?: Opts<t.ObjectMember>,
+  ): asserts this is NodePath<t.ObjectMember>;
+  assertObjectMethod(
+    opts?: Opts<t.ObjectMethod>,
+  ): asserts this is NodePath<t.ObjectMethod>;
+  assertObjectPattern(
+    opts?: Opts<t.ObjectPattern>,
+  ): asserts this is NodePath<t.ObjectPattern>;
   assertObjectProperty(
-    opts?: object,
+    opts?: Opts<t.ObjectProperty>,
   ): asserts this is NodePath<t.ObjectProperty>;
   assertObjectTypeAnnotation(
-    opts?: object,
+    opts?: Opts<t.ObjectTypeAnnotation>,
   ): asserts this is NodePath<t.ObjectTypeAnnotation>;
   assertObjectTypeCallProperty(
-    opts?: object,
+    opts?: Opts<t.ObjectTypeCallProperty>,
   ): asserts this is NodePath<t.ObjectTypeCallProperty>;
   assertObjectTypeIndexer(
-    opts?: object,
+    opts?: Opts<t.ObjectTypeIndexer>,
   ): asserts this is NodePath<t.ObjectTypeIndexer>;
   assertObjectTypeInternalSlot(
-    opts?: object,
+    opts?: Opts<t.ObjectTypeInternalSlot>,
   ): asserts this is NodePath<t.ObjectTypeInternalSlot>;
   assertObjectTypeProperty(
-    opts?: object,
+    opts?: Opts<t.ObjectTypeProperty>,
   ): asserts this is NodePath<t.ObjectTypeProperty>;
   assertObjectTypeSpreadProperty(
-    opts?: object,
+    opts?: Opts<t.ObjectTypeSpreadProperty>,
   ): asserts this is NodePath<t.ObjectTypeSpreadProperty>;
-  assertOpaqueType(opts?: object): asserts this is NodePath<t.OpaqueType>;
+  assertOpaqueType(
+    opts?: Opts<t.OpaqueType>,
+  ): asserts this is NodePath<t.OpaqueType>;
   assertOptionalCallExpression(
-    opts?: object,
+    opts?: Opts<t.OptionalCallExpression>,
   ): asserts this is NodePath<t.OptionalCallExpression>;
   assertOptionalIndexedAccessType(
-    opts?: object,
+    opts?: Opts<t.OptionalIndexedAccessType>,
   ): asserts this is NodePath<t.OptionalIndexedAccessType>;
   assertOptionalMemberExpression(
-    opts?: object,
+    opts?: Opts<t.OptionalMemberExpression>,
   ): asserts this is NodePath<t.OptionalMemberExpression>;
   assertParenthesizedExpression(
-    opts?: object,
+    opts?: Opts<t.ParenthesizedExpression>,
   ): asserts this is NodePath<t.ParenthesizedExpression>;
-  assertPattern(opts?: object): asserts this is NodePath<t.Pattern>;
-  assertPatternLike(opts?: object): asserts this is NodePath<t.PatternLike>;
+  assertPattern(opts?: Opts<t.Pattern>): asserts this is NodePath<t.Pattern>;
+  assertPatternLike(
+    opts?: Opts<t.PatternLike>,
+  ): asserts this is NodePath<t.PatternLike>;
   assertPipelineBareFunction(
-    opts?: object,
+    opts?: Opts<t.PipelineBareFunction>,
   ): asserts this is NodePath<t.PipelineBareFunction>;
   assertPipelinePrimaryTopicReference(
-    opts?: object,
+    opts?: Opts<t.PipelinePrimaryTopicReference>,
   ): asserts this is NodePath<t.PipelinePrimaryTopicReference>;
   assertPipelineTopicExpression(
-    opts?: object,
+    opts?: Opts<t.PipelineTopicExpression>,
   ): asserts this is NodePath<t.PipelineTopicExpression>;
-  assertPlaceholder(opts?: object): asserts this is NodePath<t.Placeholder>;
-  assertPrivate(opts?: object): asserts this is NodePath<t.Private>;
-  assertPrivateName(opts?: object): asserts this is NodePath<t.PrivateName>;
-  assertProgram(opts?: object): asserts this is NodePath<t.Program>;
-  assertProperty(opts?: object): asserts this is NodePath<t.Property>;
-  assertPureish(opts?: object): asserts this is NodePath<t.Pureish>;
+  assertPlaceholder(
+    opts?: Opts<t.Placeholder>,
+  ): asserts this is NodePath<t.Placeholder>;
+  assertPrivate(opts?: Opts<t.Private>): asserts this is NodePath<t.Private>;
+  assertPrivateName(
+    opts?: Opts<t.PrivateName>,
+  ): asserts this is NodePath<t.PrivateName>;
+  assertProgram(opts?: Opts<t.Program>): asserts this is NodePath<t.Program>;
+  assertProperty(opts?: Opts<t.Property>): asserts this is NodePath<t.Property>;
+  assertPureish(opts?: Opts<t.Pureish>): asserts this is NodePath<t.Pureish>;
   assertQualifiedTypeIdentifier(
-    opts?: object,
+    opts?: Opts<t.QualifiedTypeIdentifier>,
   ): asserts this is NodePath<t.QualifiedTypeIdentifier>;
   assertRecordExpression(
-    opts?: object,
+    opts?: Opts<t.RecordExpression>,
   ): asserts this is NodePath<t.RecordExpression>;
-  assertRegExpLiteral(opts?: object): asserts this is NodePath<t.RegExpLiteral>;
-  assertRegexLiteral(opts?: object): asserts this is NodePath<t.RegexLiteral>;
-  assertRestElement(opts?: object): asserts this is NodePath<t.RestElement>;
-  assertRestProperty(opts?: object): asserts this is NodePath<t.RestProperty>;
+  assertRegExpLiteral(
+    opts?: Opts<t.RegExpLiteral>,
+  ): asserts this is NodePath<t.RegExpLiteral>;
+  assertRegexLiteral(
+    opts?: Opts<t.RegexLiteral>,
+  ): asserts this is NodePath<t.RegexLiteral>;
+  assertRestElement(
+    opts?: Opts<t.RestElement>,
+  ): asserts this is NodePath<t.RestElement>;
+  assertRestProperty(
+    opts?: Opts<t.RestProperty>,
+  ): asserts this is NodePath<t.RestProperty>;
   assertReturnStatement(
-    opts?: object,
+    opts?: Opts<t.ReturnStatement>,
   ): asserts this is NodePath<t.ReturnStatement>;
-  assertScopable(opts?: object): asserts this is NodePath<t.Scopable>;
+  assertScopable(opts?: Opts<t.Scopable>): asserts this is NodePath<t.Scopable>;
   assertSequenceExpression(
-    opts?: object,
+    opts?: Opts<t.SequenceExpression>,
   ): asserts this is NodePath<t.SequenceExpression>;
-  assertSpreadElement(opts?: object): asserts this is NodePath<t.SpreadElement>;
+  assertSpreadElement(
+    opts?: Opts<t.SpreadElement>,
+  ): asserts this is NodePath<t.SpreadElement>;
   assertSpreadProperty(
-    opts?: object,
+    opts?: Opts<t.SpreadProperty>,
   ): asserts this is NodePath<t.SpreadProperty>;
-  assertStandardized(opts?: object): asserts this is NodePath<t.Standardized>;
-  assertStatement(opts?: object): asserts this is NodePath<t.Statement>;
-  assertStaticBlock(opts?: object): asserts this is NodePath<t.StaticBlock>;
-  assertStringLiteral(opts?: object): asserts this is NodePath<t.StringLiteral>;
+  assertStandardized(
+    opts?: Opts<t.Standardized>,
+  ): asserts this is NodePath<t.Standardized>;
+  assertStatement(
+    opts?: Opts<t.Statement>,
+  ): asserts this is NodePath<t.Statement>;
+  assertStaticBlock(
+    opts?: Opts<t.StaticBlock>,
+  ): asserts this is NodePath<t.StaticBlock>;
+  assertStringLiteral(
+    opts?: Opts<t.StringLiteral>,
+  ): asserts this is NodePath<t.StringLiteral>;
   assertStringLiteralTypeAnnotation(
-    opts?: object,
+    opts?: Opts<t.StringLiteralTypeAnnotation>,
   ): asserts this is NodePath<t.StringLiteralTypeAnnotation>;
   assertStringTypeAnnotation(
-    opts?: object,
+    opts?: Opts<t.StringTypeAnnotation>,
   ): asserts this is NodePath<t.StringTypeAnnotation>;
-  assertSuper(opts?: object): asserts this is NodePath<t.Super>;
-  assertSwitchCase(opts?: object): asserts this is NodePath<t.SwitchCase>;
+  assertSuper(opts?: Opts<t.Super>): asserts this is NodePath<t.Super>;
+  assertSwitchCase(
+    opts?: Opts<t.SwitchCase>,
+  ): asserts this is NodePath<t.SwitchCase>;
   assertSwitchStatement(
-    opts?: object,
+    opts?: Opts<t.SwitchStatement>,
   ): asserts this is NodePath<t.SwitchStatement>;
   assertSymbolTypeAnnotation(
-    opts?: object,
+    opts?: Opts<t.SymbolTypeAnnotation>,
   ): asserts this is NodePath<t.SymbolTypeAnnotation>;
-  assertTSAnyKeyword(opts?: object): asserts this is NodePath<t.TSAnyKeyword>;
-  assertTSArrayType(opts?: object): asserts this is NodePath<t.TSArrayType>;
+  assertTSAnyKeyword(
+    opts?: Opts<t.TSAnyKeyword>,
+  ): asserts this is NodePath<t.TSAnyKeyword>;
+  assertTSArrayType(
+    opts?: Opts<t.TSArrayType>,
+  ): asserts this is NodePath<t.TSArrayType>;
   assertTSAsExpression(
-    opts?: object,
+    opts?: Opts<t.TSAsExpression>,
   ): asserts this is NodePath<t.TSAsExpression>;
-  assertTSBaseType(opts?: object): asserts this is NodePath<t.TSBaseType>;
+  assertTSBaseType(
+    opts?: Opts<t.TSBaseType>,
+  ): asserts this is NodePath<t.TSBaseType>;
   assertTSBigIntKeyword(
-    opts?: object,
+    opts?: Opts<t.TSBigIntKeyword>,
   ): asserts this is NodePath<t.TSBigIntKeyword>;
   assertTSBooleanKeyword(
-    opts?: object,
+    opts?: Opts<t.TSBooleanKeyword>,
   ): asserts this is NodePath<t.TSBooleanKeyword>;
   assertTSCallSignatureDeclaration(
-    opts?: object,
+    opts?: Opts<t.TSCallSignatureDeclaration>,
   ): asserts this is NodePath<t.TSCallSignatureDeclaration>;
   assertTSConditionalType(
-    opts?: object,
+    opts?: Opts<t.TSConditionalType>,
   ): asserts this is NodePath<t.TSConditionalType>;
   assertTSConstructSignatureDeclaration(
-    opts?: object,
+    opts?: Opts<t.TSConstructSignatureDeclaration>,
   ): asserts this is NodePath<t.TSConstructSignatureDeclaration>;
   assertTSConstructorType(
-    opts?: object,
+    opts?: Opts<t.TSConstructorType>,
   ): asserts this is NodePath<t.TSConstructorType>;
   assertTSDeclareFunction(
-    opts?: object,
+    opts?: Opts<t.TSDeclareFunction>,
   ): asserts this is NodePath<t.TSDeclareFunction>;
   assertTSDeclareMethod(
-    opts?: object,
+    opts?: Opts<t.TSDeclareMethod>,
   ): asserts this is NodePath<t.TSDeclareMethod>;
-  assertTSEntityName(opts?: object): asserts this is NodePath<t.TSEntityName>;
+  assertTSEntityName(
+    opts?: Opts<t.TSEntityName>,
+  ): asserts this is NodePath<t.TSEntityName>;
   assertTSEnumDeclaration(
-    opts?: object,
+    opts?: Opts<t.TSEnumDeclaration>,
   ): asserts this is NodePath<t.TSEnumDeclaration>;
-  assertTSEnumMember(opts?: object): asserts this is NodePath<t.TSEnumMember>;
+  assertTSEnumMember(
+    opts?: Opts<t.TSEnumMember>,
+  ): asserts this is NodePath<t.TSEnumMember>;
   assertTSExportAssignment(
-    opts?: object,
+    opts?: Opts<t.TSExportAssignment>,
   ): asserts this is NodePath<t.TSExportAssignment>;
   assertTSExpressionWithTypeArguments(
-    opts?: object,
+    opts?: Opts<t.TSExpressionWithTypeArguments>,
   ): asserts this is NodePath<t.TSExpressionWithTypeArguments>;
   assertTSExternalModuleReference(
-    opts?: object,
+    opts?: Opts<t.TSExternalModuleReference>,
   ): asserts this is NodePath<t.TSExternalModuleReference>;
   assertTSFunctionType(
-    opts?: object,
+    opts?: Opts<t.TSFunctionType>,
   ): asserts this is NodePath<t.TSFunctionType>;
   assertTSImportEqualsDeclaration(
-    opts?: object,
+    opts?: Opts<t.TSImportEqualsDeclaration>,
   ): asserts this is NodePath<t.TSImportEqualsDeclaration>;
-  assertTSImportType(opts?: object): asserts this is NodePath<t.TSImportType>;
+  assertTSImportType(
+    opts?: Opts<t.TSImportType>,
+  ): asserts this is NodePath<t.TSImportType>;
   assertTSIndexSignature(
-    opts?: object,
+    opts?: Opts<t.TSIndexSignature>,
   ): asserts this is NodePath<t.TSIndexSignature>;
   assertTSIndexedAccessType(
-    opts?: object,
+    opts?: Opts<t.TSIndexedAccessType>,
   ): asserts this is NodePath<t.TSIndexedAccessType>;
-  assertTSInferType(opts?: object): asserts this is NodePath<t.TSInferType>;
+  assertTSInferType(
+    opts?: Opts<t.TSInferType>,
+  ): asserts this is NodePath<t.TSInferType>;
   assertTSInstantiationExpression(
-    opts?: object,
+    opts?: Opts<t.TSInstantiationExpression>,
   ): asserts this is NodePath<t.TSInstantiationExpression>;
   assertTSInterfaceBody(
-    opts?: object,
+    opts?: Opts<t.TSInterfaceBody>,
   ): asserts this is NodePath<t.TSInterfaceBody>;
   assertTSInterfaceDeclaration(
-    opts?: object,
+    opts?: Opts<t.TSInterfaceDeclaration>,
   ): asserts this is NodePath<t.TSInterfaceDeclaration>;
   assertTSIntersectionType(
-    opts?: object,
+    opts?: Opts<t.TSIntersectionType>,
   ): asserts this is NodePath<t.TSIntersectionType>;
   assertTSIntrinsicKeyword(
-    opts?: object,
+    opts?: Opts<t.TSIntrinsicKeyword>,
   ): asserts this is NodePath<t.TSIntrinsicKeyword>;
-  assertTSLiteralType(opts?: object): asserts this is NodePath<t.TSLiteralType>;
-  assertTSMappedType(opts?: object): asserts this is NodePath<t.TSMappedType>;
+  assertTSLiteralType(
+    opts?: Opts<t.TSLiteralType>,
+  ): asserts this is NodePath<t.TSLiteralType>;
+  assertTSMappedType(
+    opts?: Opts<t.TSMappedType>,
+  ): asserts this is NodePath<t.TSMappedType>;
   assertTSMethodSignature(
-    opts?: object,
+    opts?: Opts<t.TSMethodSignature>,
   ): asserts this is NodePath<t.TSMethodSignature>;
-  assertTSModuleBlock(opts?: object): asserts this is NodePath<t.TSModuleBlock>;
+  assertTSModuleBlock(
+    opts?: Opts<t.TSModuleBlock>,
+  ): asserts this is NodePath<t.TSModuleBlock>;
   assertTSModuleDeclaration(
-    opts?: object,
+    opts?: Opts<t.TSModuleDeclaration>,
   ): asserts this is NodePath<t.TSModuleDeclaration>;
   assertTSNamedTupleMember(
-    opts?: object,
+    opts?: Opts<t.TSNamedTupleMember>,
   ): asserts this is NodePath<t.TSNamedTupleMember>;
   assertTSNamespaceExportDeclaration(
-    opts?: object,
+    opts?: Opts<t.TSNamespaceExportDeclaration>,
   ): asserts this is NodePath<t.TSNamespaceExportDeclaration>;
   assertTSNeverKeyword(
-    opts?: object,
+    opts?: Opts<t.TSNeverKeyword>,
   ): asserts this is NodePath<t.TSNeverKeyword>;
   assertTSNonNullExpression(
-    opts?: object,
+    opts?: Opts<t.TSNonNullExpression>,
   ): asserts this is NodePath<t.TSNonNullExpression>;
-  assertTSNullKeyword(opts?: object): asserts this is NodePath<t.TSNullKeyword>;
+  assertTSNullKeyword(
+    opts?: Opts<t.TSNullKeyword>,
+  ): asserts this is NodePath<t.TSNullKeyword>;
   assertTSNumberKeyword(
-    opts?: object,
+    opts?: Opts<t.TSNumberKeyword>,
   ): asserts this is NodePath<t.TSNumberKeyword>;
   assertTSObjectKeyword(
-    opts?: object,
+    opts?: Opts<t.TSObjectKeyword>,
   ): asserts this is NodePath<t.TSObjectKeyword>;
   assertTSOptionalType(
-    opts?: object,
+    opts?: Opts<t.TSOptionalType>,
   ): asserts this is NodePath<t.TSOptionalType>;
   assertTSParameterProperty(
-    opts?: object,
+    opts?: Opts<t.TSParameterProperty>,
   ): asserts this is NodePath<t.TSParameterProperty>;
   assertTSParenthesizedType(
-    opts?: object,
+    opts?: Opts<t.TSParenthesizedType>,
   ): asserts this is NodePath<t.TSParenthesizedType>;
   assertTSPropertySignature(
-    opts?: object,
+    opts?: Opts<t.TSPropertySignature>,
   ): asserts this is NodePath<t.TSPropertySignature>;
   assertTSQualifiedName(
-    opts?: object,
+    opts?: Opts<t.TSQualifiedName>,
   ): asserts this is NodePath<t.TSQualifiedName>;
-  assertTSRestType(opts?: object): asserts this is NodePath<t.TSRestType>;
+  assertTSRestType(
+    opts?: Opts<t.TSRestType>,
+  ): asserts this is NodePath<t.TSRestType>;
   assertTSSatisfiesExpression(
-    opts?: object,
+    opts?: Opts<t.TSSatisfiesExpression>,
   ): asserts this is NodePath<t.TSSatisfiesExpression>;
   assertTSStringKeyword(
-    opts?: object,
+    opts?: Opts<t.TSStringKeyword>,
   ): asserts this is NodePath<t.TSStringKeyword>;
   assertTSSymbolKeyword(
-    opts?: object,
+    opts?: Opts<t.TSSymbolKeyword>,
   ): asserts this is NodePath<t.TSSymbolKeyword>;
-  assertTSThisType(opts?: object): asserts this is NodePath<t.TSThisType>;
-  assertTSTupleType(opts?: object): asserts this is NodePath<t.TSTupleType>;
-  assertTSType(opts?: object): asserts this is NodePath<t.TSType>;
+  assertTSThisType(
+    opts?: Opts<t.TSThisType>,
+  ): asserts this is NodePath<t.TSThisType>;
+  assertTSTupleType(
+    opts?: Opts<t.TSTupleType>,
+  ): asserts this is NodePath<t.TSTupleType>;
+  assertTSType(opts?: Opts<t.TSType>): asserts this is NodePath<t.TSType>;
   assertTSTypeAliasDeclaration(
-    opts?: object,
+    opts?: Opts<t.TSTypeAliasDeclaration>,
   ): asserts this is NodePath<t.TSTypeAliasDeclaration>;
   assertTSTypeAnnotation(
-    opts?: object,
+    opts?: Opts<t.TSTypeAnnotation>,
   ): asserts this is NodePath<t.TSTypeAnnotation>;
   assertTSTypeAssertion(
-    opts?: object,
+    opts?: Opts<t.TSTypeAssertion>,
   ): asserts this is NodePath<t.TSTypeAssertion>;
-  assertTSTypeElement(opts?: object): asserts this is NodePath<t.TSTypeElement>;
-  assertTSTypeLiteral(opts?: object): asserts this is NodePath<t.TSTypeLiteral>;
+  assertTSTypeElement(
+    opts?: Opts<t.TSTypeElement>,
+  ): asserts this is NodePath<t.TSTypeElement>;
+  assertTSTypeLiteral(
+    opts?: Opts<t.TSTypeLiteral>,
+  ): asserts this is NodePath<t.TSTypeLiteral>;
   assertTSTypeOperator(
-    opts?: object,
+    opts?: Opts<t.TSTypeOperator>,
   ): asserts this is NodePath<t.TSTypeOperator>;
   assertTSTypeParameter(
-    opts?: object,
+    opts?: Opts<t.TSTypeParameter>,
   ): asserts this is NodePath<t.TSTypeParameter>;
   assertTSTypeParameterDeclaration(
-    opts?: object,
+    opts?: Opts<t.TSTypeParameterDeclaration>,
   ): asserts this is NodePath<t.TSTypeParameterDeclaration>;
   assertTSTypeParameterInstantiation(
-    opts?: object,
+    opts?: Opts<t.TSTypeParameterInstantiation>,
   ): asserts this is NodePath<t.TSTypeParameterInstantiation>;
   assertTSTypePredicate(
-    opts?: object,
+    opts?: Opts<t.TSTypePredicate>,
   ): asserts this is NodePath<t.TSTypePredicate>;
-  assertTSTypeQuery(opts?: object): asserts this is NodePath<t.TSTypeQuery>;
+  assertTSTypeQuery(
+    opts?: Opts<t.TSTypeQuery>,
+  ): asserts this is NodePath<t.TSTypeQuery>;
   assertTSTypeReference(
-    opts?: object,
+    opts?: Opts<t.TSTypeReference>,
   ): asserts this is NodePath<t.TSTypeReference>;
   assertTSUndefinedKeyword(
-    opts?: object,
+    opts?: Opts<t.TSUndefinedKeyword>,
   ): asserts this is NodePath<t.TSUndefinedKeyword>;
-  assertTSUnionType(opts?: object): asserts this is NodePath<t.TSUnionType>;
+  assertTSUnionType(
+    opts?: Opts<t.TSUnionType>,
+  ): asserts this is NodePath<t.TSUnionType>;
   assertTSUnknownKeyword(
-    opts?: object,
+    opts?: Opts<t.TSUnknownKeyword>,
   ): asserts this is NodePath<t.TSUnknownKeyword>;
-  assertTSVoidKeyword(opts?: object): asserts this is NodePath<t.TSVoidKeyword>;
+  assertTSVoidKeyword(
+    opts?: Opts<t.TSVoidKeyword>,
+  ): asserts this is NodePath<t.TSVoidKeyword>;
   assertTaggedTemplateExpression(
-    opts?: object,
+    opts?: Opts<t.TaggedTemplateExpression>,
   ): asserts this is NodePath<t.TaggedTemplateExpression>;
   assertTemplateElement(
-    opts?: object,
+    opts?: Opts<t.TemplateElement>,
   ): asserts this is NodePath<t.TemplateElement>;
   assertTemplateLiteral(
-    opts?: object,
+    opts?: Opts<t.TemplateLiteral>,
   ): asserts this is NodePath<t.TemplateLiteral>;
   assertTerminatorless(
-    opts?: object,
+    opts?: Opts<t.Terminatorless>,
   ): asserts this is NodePath<t.Terminatorless>;
   assertThisExpression(
-    opts?: object,
+    opts?: Opts<t.ThisExpression>,
   ): asserts this is NodePath<t.ThisExpression>;
   assertThisTypeAnnotation(
-    opts?: object,
+    opts?: Opts<t.ThisTypeAnnotation>,
   ): asserts this is NodePath<t.ThisTypeAnnotation>;
   assertThrowStatement(
-    opts?: object,
+    opts?: Opts<t.ThrowStatement>,
   ): asserts this is NodePath<t.ThrowStatement>;
   assertTopicReference(
-    opts?: object,
+    opts?: Opts<t.TopicReference>,
   ): asserts this is NodePath<t.TopicReference>;
-  assertTryStatement(opts?: object): asserts this is NodePath<t.TryStatement>;
+  assertTryStatement(
+    opts?: Opts<t.TryStatement>,
+  ): asserts this is NodePath<t.TryStatement>;
   assertTupleExpression(
-    opts?: object,
+    opts?: Opts<t.TupleExpression>,
   ): asserts this is NodePath<t.TupleExpression>;
   assertTupleTypeAnnotation(
-    opts?: object,
+    opts?: Opts<t.TupleTypeAnnotation>,
   ): asserts this is NodePath<t.TupleTypeAnnotation>;
-  assertTypeAlias(opts?: object): asserts this is NodePath<t.TypeAlias>;
+  assertTypeAlias(
+    opts?: Opts<t.TypeAlias>,
+  ): asserts this is NodePath<t.TypeAlias>;
   assertTypeAnnotation(
-    opts?: object,
+    opts?: Opts<t.TypeAnnotation>,
   ): asserts this is NodePath<t.TypeAnnotation>;
   assertTypeCastExpression(
-    opts?: object,
+    opts?: Opts<t.TypeCastExpression>,
   ): asserts this is NodePath<t.TypeCastExpression>;
-  assertTypeParameter(opts?: object): asserts this is NodePath<t.TypeParameter>;
+  assertTypeParameter(
+    opts?: Opts<t.TypeParameter>,
+  ): asserts this is NodePath<t.TypeParameter>;
   assertTypeParameterDeclaration(
-    opts?: object,
+    opts?: Opts<t.TypeParameterDeclaration>,
   ): asserts this is NodePath<t.TypeParameterDeclaration>;
   assertTypeParameterInstantiation(
-    opts?: object,
+    opts?: Opts<t.TypeParameterInstantiation>,
   ): asserts this is NodePath<t.TypeParameterInstantiation>;
-  assertTypeScript(opts?: object): asserts this is NodePath<t.TypeScript>;
+  assertTypeScript(
+    opts?: Opts<t.TypeScript>,
+  ): asserts this is NodePath<t.TypeScript>;
   assertTypeofTypeAnnotation(
-    opts?: object,
+    opts?: Opts<t.TypeofTypeAnnotation>,
   ): asserts this is NodePath<t.TypeofTypeAnnotation>;
   assertUnaryExpression(
-    opts?: object,
+    opts?: Opts<t.UnaryExpression>,
   ): asserts this is NodePath<t.UnaryExpression>;
-  assertUnaryLike(opts?: object): asserts this is NodePath<t.UnaryLike>;
+  assertUnaryLike(
+    opts?: Opts<t.UnaryLike>,
+  ): asserts this is NodePath<t.UnaryLike>;
   assertUnionTypeAnnotation(
-    opts?: object,
+    opts?: Opts<t.UnionTypeAnnotation>,
   ): asserts this is NodePath<t.UnionTypeAnnotation>;
   assertUpdateExpression(
-    opts?: object,
+    opts?: Opts<t.UpdateExpression>,
   ): asserts this is NodePath<t.UpdateExpression>;
   assertUserWhitespacable(
-    opts?: object,
+    opts?: Opts<t.UserWhitespacable>,
   ): asserts this is NodePath<t.UserWhitespacable>;
   assertV8IntrinsicIdentifier(
-    opts?: object,
+    opts?: Opts<t.V8IntrinsicIdentifier>,
   ): asserts this is NodePath<t.V8IntrinsicIdentifier>;
   assertVariableDeclaration(
-    opts?: object,
+    opts?: Opts<t.VariableDeclaration>,
   ): asserts this is NodePath<t.VariableDeclaration>;
   assertVariableDeclarator(
-    opts?: object,
+    opts?: Opts<t.VariableDeclarator>,
   ): asserts this is NodePath<t.VariableDeclarator>;
-  assertVariance(opts?: object): asserts this is NodePath<t.Variance>;
+  assertVariance(opts?: Opts<t.Variance>): asserts this is NodePath<t.Variance>;
   assertVoidTypeAnnotation(
-    opts?: object,
+    opts?: Opts<t.VoidTypeAnnotation>,
   ): asserts this is NodePath<t.VoidTypeAnnotation>;
-  assertWhile(opts?: object): asserts this is NodePath<t.While>;
+  assertWhile(opts?: Opts<t.While>): asserts this is NodePath<t.While>;
   assertWhileStatement(
-    opts?: object,
+    opts?: Opts<t.WhileStatement>,
   ): asserts this is NodePath<t.WhileStatement>;
-  assertWithStatement(opts?: object): asserts this is NodePath<t.WithStatement>;
+  assertWithStatement(
+    opts?: Opts<t.WithStatement>,
+  ): asserts this is NodePath<t.WithStatement>;
   assertYieldExpression(
-    opts?: object,
+    opts?: Opts<t.YieldExpression>,
   ): asserts this is NodePath<t.YieldExpression>;
 }
diff --git a/packages/babel-traverse/src/path/generated/validators.d.ts b/packages/babel-traverse/src/path/generated/validators.d.ts
index 470d7c47be62..8854fa3d6c0e 100644
--- a/packages/babel-traverse/src/path/generated/validators.d.ts
+++ b/packages/babel-traverse/src/path/generated/validators.d.ts
@@ -6,1221 +6,1229 @@ import type * as t from "@babel/types";
 import type NodePath from "../index";
 import type { VirtualTypeNodePathValidators } from "../lib/virtual-types-validator";
 
+type Opts<Obj> = Partial<{
+  [Prop in keyof Obj]: Obj[Prop] extends t.Node
+    ? t.Node
+    : Obj[Prop] extends t.Node[]
+    ? t.Node[]
+    : Obj[Prop];
+}>;
+
 interface BaseNodePathValidators {
   isAccessor<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.Accessor>,
   ): this is NodePath<T & t.Accessor>;
   isAnyTypeAnnotation<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.AnyTypeAnnotation>,
   ): this is NodePath<T & t.AnyTypeAnnotation>;
   isArgumentPlaceholder<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.ArgumentPlaceholder>,
   ): this is NodePath<T & t.ArgumentPlaceholder>;
   isArrayExpression<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.ArrayExpression>,
   ): this is NodePath<T & t.ArrayExpression>;
   isArrayPattern<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.ArrayPattern>,
   ): this is NodePath<T & t.ArrayPattern>;
   isArrayTypeAnnotation<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.ArrayTypeAnnotation>,
   ): this is NodePath<T & t.ArrayTypeAnnotation>;
   isArrowFunctionExpression<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.ArrowFunctionExpression>,
   ): this is NodePath<T & t.ArrowFunctionExpression>;
   isAssignmentExpression<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.AssignmentExpression>,
   ): this is NodePath<T & t.AssignmentExpression>;
   isAssignmentPattern<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.AssignmentPattern>,
   ): this is NodePath<T & t.AssignmentPattern>;
   isAwaitExpression<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.AwaitExpression>,
   ): this is NodePath<T & t.AwaitExpression>;
   isBigIntLiteral<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.BigIntLiteral>,
   ): this is NodePath<T & t.BigIntLiteral>;
   isBinary<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.Binary>,
   ): this is NodePath<T & t.Binary>;
   isBinaryExpression<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.BinaryExpression>,
   ): this is NodePath<T & t.BinaryExpression>;
   isBindExpression<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.BindExpression>,
   ): this is NodePath<T & t.BindExpression>;
   isBlock<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.Block>,
   ): this is NodePath<T & t.Block>;
   isBlockParent<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.BlockParent>,
   ): this is NodePath<T & t.BlockParent>;
   isBlockStatement<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.BlockStatement>,
   ): this is NodePath<T & t.BlockStatement>;
   isBooleanLiteral<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.BooleanLiteral>,
   ): this is NodePath<T & t.BooleanLiteral>;
   isBooleanLiteralTypeAnnotation<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.BooleanLiteralTypeAnnotation>,
   ): this is NodePath<T & t.BooleanLiteralTypeAnnotation>;
   isBooleanTypeAnnotation<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.BooleanTypeAnnotation>,
   ): this is NodePath<T & t.BooleanTypeAnnotation>;
   isBreakStatement<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.BreakStatement>,
   ): this is NodePath<T & t.BreakStatement>;
   isCallExpression<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.CallExpression>,
   ): this is NodePath<T & t.CallExpression>;
   isCatchClause<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.CatchClause>,
   ): this is NodePath<T & t.CatchClause>;
   isClass<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.Class>,
   ): this is NodePath<T & t.Class>;
   isClassAccessorProperty<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.ClassAccessorProperty>,
   ): this is NodePath<T & t.ClassAccessorProperty>;
   isClassBody<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.ClassBody>,
   ): this is NodePath<T & t.ClassBody>;
   isClassDeclaration<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.ClassDeclaration>,
   ): this is NodePath<T & t.ClassDeclaration>;
   isClassExpression<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.ClassExpression>,
   ): this is NodePath<T & t.ClassExpression>;
   isClassImplements<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.ClassImplements>,
   ): this is NodePath<T & t.ClassImplements>;
   isClassMethod<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.ClassMethod>,
   ): this is NodePath<T & t.ClassMethod>;
   isClassPrivateMethod<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.ClassPrivateMethod>,
   ): this is NodePath<T & t.ClassPrivateMethod>;
   isClassPrivateProperty<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.ClassPrivateProperty>,
   ): this is NodePath<T & t.ClassPrivateProperty>;
   isClassProperty<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.ClassProperty>,
   ): this is NodePath<T & t.ClassProperty>;
   isCompletionStatement<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.CompletionStatement>,
   ): this is NodePath<T & t.CompletionStatement>;
   isConditional<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.Conditional>,
   ): this is NodePath<T & t.Conditional>;
   isConditionalExpression<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.ConditionalExpression>,
   ): this is NodePath<T & t.ConditionalExpression>;
   isContinueStatement<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.ContinueStatement>,
   ): this is NodePath<T & t.ContinueStatement>;
   isDebuggerStatement<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.DebuggerStatement>,
   ): this is NodePath<T & t.DebuggerStatement>;
   isDecimalLiteral<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.DecimalLiteral>,
   ): this is NodePath<T & t.DecimalLiteral>;
   isDeclaration<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.Declaration>,
   ): this is NodePath<T & t.Declaration>;
   isDeclareClass<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.DeclareClass>,
   ): this is NodePath<T & t.DeclareClass>;
   isDeclareExportAllDeclaration<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.DeclareExportAllDeclaration>,
   ): this is NodePath<T & t.DeclareExportAllDeclaration>;
   isDeclareExportDeclaration<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.DeclareExportDeclaration>,
   ): this is NodePath<T & t.DeclareExportDeclaration>;
   isDeclareFunction<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.DeclareFunction>,
   ): this is NodePath<T & t.DeclareFunction>;
   isDeclareInterface<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.DeclareInterface>,
   ): this is NodePath<T & t.DeclareInterface>;
   isDeclareModule<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.DeclareModule>,
   ): this is NodePath<T & t.DeclareModule>;
   isDeclareModuleExports<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.DeclareModuleExports>,
   ): this is NodePath<T & t.DeclareModuleExports>;
   isDeclareOpaqueType<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.DeclareOpaqueType>,
   ): this is NodePath<T & t.DeclareOpaqueType>;
   isDeclareTypeAlias<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.DeclareTypeAlias>,
   ): this is NodePath<T & t.DeclareTypeAlias>;
   isDeclareVariable<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.DeclareVariable>,
   ): this is NodePath<T & t.DeclareVariable>;
   isDeclaredPredicate<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.DeclaredPredicate>,
   ): this is NodePath<T & t.DeclaredPredicate>;
   isDecorator<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.Decorator>,
   ): this is NodePath<T & t.Decorator>;
   isDirective<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.Directive>,
   ): this is NodePath<T & t.Directive>;
   isDirectiveLiteral<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.DirectiveLiteral>,
   ): this is NodePath<T & t.DirectiveLiteral>;
   isDoExpression<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.DoExpression>,
   ): this is NodePath<T & t.DoExpression>;
   isDoWhileStatement<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.DoWhileStatement>,
   ): this is NodePath<T & t.DoWhileStatement>;
   isEmptyStatement<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.EmptyStatement>,
   ): this is NodePath<T & t.EmptyStatement>;
   isEmptyTypeAnnotation<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.EmptyTypeAnnotation>,
   ): this is NodePath<T & t.EmptyTypeAnnotation>;
   isEnumBody<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.EnumBody>,
   ): this is NodePath<T & t.EnumBody>;
   isEnumBooleanBody<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.EnumBooleanBody>,
   ): this is NodePath<T & t.EnumBooleanBody>;
   isEnumBooleanMember<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.EnumBooleanMember>,
   ): this is NodePath<T & t.EnumBooleanMember>;
   isEnumDeclaration<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.EnumDeclaration>,
   ): this is NodePath<T & t.EnumDeclaration>;
   isEnumDefaultedMember<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.EnumDefaultedMember>,
   ): this is NodePath<T & t.EnumDefaultedMember>;
   isEnumMember<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.EnumMember>,
   ): this is NodePath<T & t.EnumMember>;
   isEnumNumberBody<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.EnumNumberBody>,
   ): this is NodePath<T & t.EnumNumberBody>;
   isEnumNumberMember<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.EnumNumberMember>,
   ): this is NodePath<T & t.EnumNumberMember>;
   isEnumStringBody<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.EnumStringBody>,
   ): this is NodePath<T & t.EnumStringBody>;
   isEnumStringMember<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.EnumStringMember>,
   ): this is NodePath<T & t.EnumStringMember>;
   isEnumSymbolBody<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.EnumSymbolBody>,
   ): this is NodePath<T & t.EnumSymbolBody>;
   isExistsTypeAnnotation<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.ExistsTypeAnnotation>,
   ): this is NodePath<T & t.ExistsTypeAnnotation>;
   isExportAllDeclaration<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.ExportAllDeclaration>,
   ): this is NodePath<T & t.ExportAllDeclaration>;
   isExportDeclaration<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.ExportDeclaration>,
   ): this is NodePath<T & t.ExportDeclaration>;
   isExportDefaultDeclaration<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.ExportDefaultDeclaration>,
   ): this is NodePath<T & t.ExportDefaultDeclaration>;
   isExportDefaultSpecifier<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.ExportDefaultSpecifier>,
   ): this is NodePath<T & t.ExportDefaultSpecifier>;
   isExportNamedDeclaration<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.ExportNamedDeclaration>,
   ): this is NodePath<T & t.ExportNamedDeclaration>;
   isExportNamespaceSpecifier<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.ExportNamespaceSpecifier>,
   ): this is NodePath<T & t.ExportNamespaceSpecifier>;
   isExportSpecifier<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.ExportSpecifier>,
   ): this is NodePath<T & t.ExportSpecifier>;
   isExpression<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.Expression>,
   ): this is NodePath<T & t.Expression>;
   isExpressionStatement<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.ExpressionStatement>,
   ): this is NodePath<T & t.ExpressionStatement>;
   isExpressionWrapper<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.ExpressionWrapper>,
   ): this is NodePath<T & t.ExpressionWrapper>;
   isFile<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.File>,
   ): this is NodePath<T & t.File>;
   isFlow<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.Flow>,
   ): this is NodePath<T & t.Flow>;
   isFlowBaseAnnotation<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.FlowBaseAnnotation>,
   ): this is NodePath<T & t.FlowBaseAnnotation>;
   isFlowDeclaration<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.FlowDeclaration>,
   ): this is NodePath<T & t.FlowDeclaration>;
   isFlowPredicate<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.FlowPredicate>,
   ): this is NodePath<T & t.FlowPredicate>;
   isFlowType<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.FlowType>,
   ): this is NodePath<T & t.FlowType>;
   isFor<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.For>,
   ): this is NodePath<T & t.For>;
   isForInStatement<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.ForInStatement>,
   ): this is NodePath<T & t.ForInStatement>;
   isForOfStatement<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.ForOfStatement>,
   ): this is NodePath<T & t.ForOfStatement>;
   isForStatement<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.ForStatement>,
   ): this is NodePath<T & t.ForStatement>;
   isForXStatement<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.ForXStatement>,
   ): this is NodePath<T & t.ForXStatement>;
   isFunction<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.Function>,
   ): this is NodePath<T & t.Function>;
   isFunctionDeclaration<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.FunctionDeclaration>,
   ): this is NodePath<T & t.FunctionDeclaration>;
   isFunctionExpression<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.FunctionExpression>,
   ): this is NodePath<T & t.FunctionExpression>;
   isFunctionParent<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.FunctionParent>,
   ): this is NodePath<T & t.FunctionParent>;
   isFunctionTypeAnnotation<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.FunctionTypeAnnotation>,
   ): this is NodePath<T & t.FunctionTypeAnnotation>;
   isFunctionTypeParam<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.FunctionTypeParam>,
   ): this is NodePath<T & t.FunctionTypeParam>;
   isGenericTypeAnnotation<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.GenericTypeAnnotation>,
   ): this is NodePath<T & t.GenericTypeAnnotation>;
   isIdentifier<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.Identifier>,
   ): this is NodePath<T & t.Identifier>;
   isIfStatement<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.IfStatement>,
   ): this is NodePath<T & t.IfStatement>;
   isImmutable<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.Immutable>,
   ): this is NodePath<T & t.Immutable>;
   isImport<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.Import>,
   ): this is NodePath<T & t.Import>;
   isImportAttribute<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.ImportAttribute>,
   ): this is NodePath<T & t.ImportAttribute>;
   isImportDeclaration<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.ImportDeclaration>,
   ): this is NodePath<T & t.ImportDeclaration>;
   isImportDefaultSpecifier<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.ImportDefaultSpecifier>,
   ): this is NodePath<T & t.ImportDefaultSpecifier>;
   isImportNamespaceSpecifier<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.ImportNamespaceSpecifier>,
   ): this is NodePath<T & t.ImportNamespaceSpecifier>;
   isImportOrExportDeclaration<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.ImportOrExportDeclaration>,
   ): this is NodePath<T & t.ImportOrExportDeclaration>;
   isImportSpecifier<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.ImportSpecifier>,
   ): this is NodePath<T & t.ImportSpecifier>;
   isIndexedAccessType<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.IndexedAccessType>,
   ): this is NodePath<T & t.IndexedAccessType>;
   isInferredPredicate<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.InferredPredicate>,
   ): this is NodePath<T & t.InferredPredicate>;
   isInterfaceDeclaration<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.InterfaceDeclaration>,
   ): this is NodePath<T & t.InterfaceDeclaration>;
   isInterfaceExtends<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.InterfaceExtends>,
   ): this is NodePath<T & t.InterfaceExtends>;
   isInterfaceTypeAnnotation<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.InterfaceTypeAnnotation>,
   ): this is NodePath<T & t.InterfaceTypeAnnotation>;
   isInterpreterDirective<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.InterpreterDirective>,
   ): this is NodePath<T & t.InterpreterDirective>;
   isIntersectionTypeAnnotation<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.IntersectionTypeAnnotation>,
   ): this is NodePath<T & t.IntersectionTypeAnnotation>;
   isJSX<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.JSX>,
   ): this is NodePath<T & t.JSX>;
   isJSXAttribute<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.JSXAttribute>,
   ): this is NodePath<T & t.JSXAttribute>;
   isJSXClosingElement<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.JSXClosingElement>,
   ): this is NodePath<T & t.JSXClosingElement>;
   isJSXClosingFragment<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.JSXClosingFragment>,
   ): this is NodePath<T & t.JSXClosingFragment>;
   isJSXElement<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.JSXElement>,
   ): this is NodePath<T & t.JSXElement>;
   isJSXEmptyExpression<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.JSXEmptyExpression>,
   ): this is NodePath<T & t.JSXEmptyExpression>;
   isJSXExpressionContainer<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.JSXExpressionContainer>,
   ): this is NodePath<T & t.JSXExpressionContainer>;
   isJSXFragment<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.JSXFragment>,
   ): this is NodePath<T & t.JSXFragment>;
   isJSXIdentifier<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.JSXIdentifier>,
   ): this is NodePath<T & t.JSXIdentifier>;
   isJSXMemberExpression<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.JSXMemberExpression>,
   ): this is NodePath<T & t.JSXMemberExpression>;
   isJSXNamespacedName<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.JSXNamespacedName>,
   ): this is NodePath<T & t.JSXNamespacedName>;
   isJSXOpeningElement<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.JSXOpeningElement>,
   ): this is NodePath<T & t.JSXOpeningElement>;
   isJSXOpeningFragment<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.JSXOpeningFragment>,
   ): this is NodePath<T & t.JSXOpeningFragment>;
   isJSXSpreadAttribute<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.JSXSpreadAttribute>,
   ): this is NodePath<T & t.JSXSpreadAttribute>;
   isJSXSpreadChild<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.JSXSpreadChild>,
   ): this is NodePath<T & t.JSXSpreadChild>;
   isJSXText<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.JSXText>,
   ): this is NodePath<T & t.JSXText>;
   isLVal<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.LVal>,
   ): this is NodePath<T & t.LVal>;
   isLabeledStatement<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.LabeledStatement>,
   ): this is NodePath<T & t.LabeledStatement>;
   isLiteral<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.Literal>,
   ): this is NodePath<T & t.Literal>;
   isLogicalExpression<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.LogicalExpression>,
   ): this is NodePath<T & t.LogicalExpression>;
   isLoop<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.Loop>,
   ): this is NodePath<T & t.Loop>;
   isMemberExpression<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.MemberExpression>,
   ): this is NodePath<T & t.MemberExpression>;
   isMetaProperty<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.MetaProperty>,
   ): this is NodePath<T & t.MetaProperty>;
   isMethod<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.Method>,
   ): this is NodePath<T & t.Method>;
   isMiscellaneous<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.Miscellaneous>,
   ): this is NodePath<T & t.Miscellaneous>;
   isMixedTypeAnnotation<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.MixedTypeAnnotation>,
   ): this is NodePath<T & t.MixedTypeAnnotation>;
   isModuleDeclaration<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.ModuleDeclaration>,
   ): this is NodePath<T & t.ModuleDeclaration>;
   isModuleExpression<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.ModuleExpression>,
   ): this is NodePath<T & t.ModuleExpression>;
   isModuleSpecifier<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.ModuleSpecifier>,
   ): this is NodePath<T & t.ModuleSpecifier>;
   isNewExpression<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.NewExpression>,
   ): this is NodePath<T & t.NewExpression>;
   isNoop<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.Noop>,
   ): this is NodePath<T & t.Noop>;
   isNullLiteral<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.NullLiteral>,
   ): this is NodePath<T & t.NullLiteral>;
   isNullLiteralTypeAnnotation<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.NullLiteralTypeAnnotation>,
   ): this is NodePath<T & t.NullLiteralTypeAnnotation>;
   isNullableTypeAnnotation<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.NullableTypeAnnotation>,
   ): this is NodePath<T & t.NullableTypeAnnotation>;
   isNumberLiteral<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.NumberLiteral>,
   ): this is NodePath<T & t.NumberLiteral>;
   isNumberLiteralTypeAnnotation<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.NumberLiteralTypeAnnotation>,
   ): this is NodePath<T & t.NumberLiteralTypeAnnotation>;
   isNumberTypeAnnotation<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.NumberTypeAnnotation>,
   ): this is NodePath<T & t.NumberTypeAnnotation>;
   isNumericLiteral<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.NumericLiteral>,
   ): this is NodePath<T & t.NumericLiteral>;
   isObjectExpression<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.ObjectExpression>,
   ): this is NodePath<T & t.ObjectExpression>;
   isObjectMember<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.ObjectMember>,
   ): this is NodePath<T & t.ObjectMember>;
   isObjectMethod<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.ObjectMethod>,
   ): this is NodePath<T & t.ObjectMethod>;
   isObjectPattern<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.ObjectPattern>,
   ): this is NodePath<T & t.ObjectPattern>;
   isObjectProperty<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.ObjectProperty>,
   ): this is NodePath<T & t.ObjectProperty>;
   isObjectTypeAnnotation<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.ObjectTypeAnnotation>,
   ): this is NodePath<T & t.ObjectTypeAnnotation>;
   isObjectTypeCallProperty<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.ObjectTypeCallProperty>,
   ): this is NodePath<T & t.ObjectTypeCallProperty>;
   isObjectTypeIndexer<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.ObjectTypeIndexer>,
   ): this is NodePath<T & t.ObjectTypeIndexer>;
   isObjectTypeInternalSlot<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.ObjectTypeInternalSlot>,
   ): this is NodePath<T & t.ObjectTypeInternalSlot>;
   isObjectTypeProperty<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.ObjectTypeProperty>,
   ): this is NodePath<T & t.ObjectTypeProperty>;
   isObjectTypeSpreadProperty<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.ObjectTypeSpreadProperty>,
   ): this is NodePath<T & t.ObjectTypeSpreadProperty>;
   isOpaqueType<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.OpaqueType>,
   ): this is NodePath<T & t.OpaqueType>;
   isOptionalCallExpression<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.OptionalCallExpression>,
   ): this is NodePath<T & t.OptionalCallExpression>;
   isOptionalIndexedAccessType<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.OptionalIndexedAccessType>,
   ): this is NodePath<T & t.OptionalIndexedAccessType>;
   isOptionalMemberExpression<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.OptionalMemberExpression>,
   ): this is NodePath<T & t.OptionalMemberExpression>;
   isParenthesizedExpression<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.ParenthesizedExpression>,
   ): this is NodePath<T & t.ParenthesizedExpression>;
   isPattern<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.Pattern>,
   ): this is NodePath<T & t.Pattern>;
   isPatternLike<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.PatternLike>,
   ): this is NodePath<T & t.PatternLike>;
   isPipelineBareFunction<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.PipelineBareFunction>,
   ): this is NodePath<T & t.PipelineBareFunction>;
   isPipelinePrimaryTopicReference<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.PipelinePrimaryTopicReference>,
   ): this is NodePath<T & t.PipelinePrimaryTopicReference>;
   isPipelineTopicExpression<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.PipelineTopicExpression>,
   ): this is NodePath<T & t.PipelineTopicExpression>;
   isPlaceholder<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.Placeholder>,
   ): this is NodePath<T & t.Placeholder>;
   isPrivate<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.Private>,
   ): this is NodePath<T & t.Private>;
   isPrivateName<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.PrivateName>,
   ): this is NodePath<T & t.PrivateName>;
   isProgram<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.Program>,
   ): this is NodePath<T & t.Program>;
   isProperty<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.Property>,
   ): this is NodePath<T & t.Property>;
   isPureish<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.Pureish>,
   ): this is NodePath<T & t.Pureish>;
   isQualifiedTypeIdentifier<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.QualifiedTypeIdentifier>,
   ): this is NodePath<T & t.QualifiedTypeIdentifier>;
   isRecordExpression<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.RecordExpression>,
   ): this is NodePath<T & t.RecordExpression>;
   isRegExpLiteral<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.RegExpLiteral>,
   ): this is NodePath<T & t.RegExpLiteral>;
   isRegexLiteral<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.RegexLiteral>,
   ): this is NodePath<T & t.RegexLiteral>;
   isRestElement<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.RestElement>,
   ): this is NodePath<T & t.RestElement>;
   isRestProperty<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.RestProperty>,
   ): this is NodePath<T & t.RestProperty>;
   isReturnStatement<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.ReturnStatement>,
   ): this is NodePath<T & t.ReturnStatement>;
   isScopable<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.Scopable>,
   ): this is NodePath<T & t.Scopable>;
   isSequenceExpression<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.SequenceExpression>,
   ): this is NodePath<T & t.SequenceExpression>;
   isSpreadElement<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.SpreadElement>,
   ): this is NodePath<T & t.SpreadElement>;
   isSpreadProperty<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.SpreadProperty>,
   ): this is NodePath<T & t.SpreadProperty>;
   isStandardized<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.Standardized>,
   ): this is NodePath<T & t.Standardized>;
   isStatement<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.Statement>,
   ): this is NodePath<T & t.Statement>;
   isStaticBlock<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.StaticBlock>,
   ): this is NodePath<T & t.StaticBlock>;
   isStringLiteral<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.StringLiteral>,
   ): this is NodePath<T & t.StringLiteral>;
   isStringLiteralTypeAnnotation<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.StringLiteralTypeAnnotation>,
   ): this is NodePath<T & t.StringLiteralTypeAnnotation>;
   isStringTypeAnnotation<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.StringTypeAnnotation>,
   ): this is NodePath<T & t.StringTypeAnnotation>;
   isSuper<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.Super>,
   ): this is NodePath<T & t.Super>;
   isSwitchCase<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.SwitchCase>,
   ): this is NodePath<T & t.SwitchCase>;
   isSwitchStatement<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.SwitchStatement>,
   ): this is NodePath<T & t.SwitchStatement>;
   isSymbolTypeAnnotation<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.SymbolTypeAnnotation>,
   ): this is NodePath<T & t.SymbolTypeAnnotation>;
   isTSAnyKeyword<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TSAnyKeyword>,
   ): this is NodePath<T & t.TSAnyKeyword>;
   isTSArrayType<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TSArrayType>,
   ): this is NodePath<T & t.TSArrayType>;
   isTSAsExpression<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TSAsExpression>,
   ): this is NodePath<T & t.TSAsExpression>;
   isTSBaseType<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TSBaseType>,
   ): this is NodePath<T & t.TSBaseType>;
   isTSBigIntKeyword<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TSBigIntKeyword>,
   ): this is NodePath<T & t.TSBigIntKeyword>;
   isTSBooleanKeyword<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TSBooleanKeyword>,
   ): this is NodePath<T & t.TSBooleanKeyword>;
   isTSCallSignatureDeclaration<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TSCallSignatureDeclaration>,
   ): this is NodePath<T & t.TSCallSignatureDeclaration>;
   isTSConditionalType<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TSConditionalType>,
   ): this is NodePath<T & t.TSConditionalType>;
   isTSConstructSignatureDeclaration<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TSConstructSignatureDeclaration>,
   ): this is NodePath<T & t.TSConstructSignatureDeclaration>;
   isTSConstructorType<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TSConstructorType>,
   ): this is NodePath<T & t.TSConstructorType>;
   isTSDeclareFunction<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TSDeclareFunction>,
   ): this is NodePath<T & t.TSDeclareFunction>;
   isTSDeclareMethod<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TSDeclareMethod>,
   ): this is NodePath<T & t.TSDeclareMethod>;
   isTSEntityName<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TSEntityName>,
   ): this is NodePath<T & t.TSEntityName>;
   isTSEnumDeclaration<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TSEnumDeclaration>,
   ): this is NodePath<T & t.TSEnumDeclaration>;
   isTSEnumMember<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TSEnumMember>,
   ): this is NodePath<T & t.TSEnumMember>;
   isTSExportAssignment<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TSExportAssignment>,
   ): this is NodePath<T & t.TSExportAssignment>;
   isTSExpressionWithTypeArguments<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TSExpressionWithTypeArguments>,
   ): this is NodePath<T & t.TSExpressionWithTypeArguments>;
   isTSExternalModuleReference<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TSExternalModuleReference>,
   ): this is NodePath<T & t.TSExternalModuleReference>;
   isTSFunctionType<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TSFunctionType>,
   ): this is NodePath<T & t.TSFunctionType>;
   isTSImportEqualsDeclaration<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TSImportEqualsDeclaration>,
   ): this is NodePath<T & t.TSImportEqualsDeclaration>;
   isTSImportType<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TSImportType>,
   ): this is NodePath<T & t.TSImportType>;
   isTSIndexSignature<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TSIndexSignature>,
   ): this is NodePath<T & t.TSIndexSignature>;
   isTSIndexedAccessType<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TSIndexedAccessType>,
   ): this is NodePath<T & t.TSIndexedAccessType>;
   isTSInferType<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TSInferType>,
   ): this is NodePath<T & t.TSInferType>;
   isTSInstantiationExpression<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TSInstantiationExpression>,
   ): this is NodePath<T & t.TSInstantiationExpression>;
   isTSInterfaceBody<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TSInterfaceBody>,
   ): this is NodePath<T & t.TSInterfaceBody>;
   isTSInterfaceDeclaration<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TSInterfaceDeclaration>,
   ): this is NodePath<T & t.TSInterfaceDeclaration>;
   isTSIntersectionType<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TSIntersectionType>,
   ): this is NodePath<T & t.TSIntersectionType>;
   isTSIntrinsicKeyword<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TSIntrinsicKeyword>,
   ): this is NodePath<T & t.TSIntrinsicKeyword>;
   isTSLiteralType<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TSLiteralType>,
   ): this is NodePath<T & t.TSLiteralType>;
   isTSMappedType<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TSMappedType>,
   ): this is NodePath<T & t.TSMappedType>;
   isTSMethodSignature<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TSMethodSignature>,
   ): this is NodePath<T & t.TSMethodSignature>;
   isTSModuleBlock<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TSModuleBlock>,
   ): this is NodePath<T & t.TSModuleBlock>;
   isTSModuleDeclaration<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TSModuleDeclaration>,
   ): this is NodePath<T & t.TSModuleDeclaration>;
   isTSNamedTupleMember<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TSNamedTupleMember>,
   ): this is NodePath<T & t.TSNamedTupleMember>;
   isTSNamespaceExportDeclaration<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TSNamespaceExportDeclaration>,
   ): this is NodePath<T & t.TSNamespaceExportDeclaration>;
   isTSNeverKeyword<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TSNeverKeyword>,
   ): this is NodePath<T & t.TSNeverKeyword>;
   isTSNonNullExpression<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TSNonNullExpression>,
   ): this is NodePath<T & t.TSNonNullExpression>;
   isTSNullKeyword<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TSNullKeyword>,
   ): this is NodePath<T & t.TSNullKeyword>;
   isTSNumberKeyword<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TSNumberKeyword>,
   ): this is NodePath<T & t.TSNumberKeyword>;
   isTSObjectKeyword<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TSObjectKeyword>,
   ): this is NodePath<T & t.TSObjectKeyword>;
   isTSOptionalType<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TSOptionalType>,
   ): this is NodePath<T & t.TSOptionalType>;
   isTSParameterProperty<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TSParameterProperty>,
   ): this is NodePath<T & t.TSParameterProperty>;
   isTSParenthesizedType<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TSParenthesizedType>,
   ): this is NodePath<T & t.TSParenthesizedType>;
   isTSPropertySignature<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TSPropertySignature>,
   ): this is NodePath<T & t.TSPropertySignature>;
   isTSQualifiedName<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TSQualifiedName>,
   ): this is NodePath<T & t.TSQualifiedName>;
   isTSRestType<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TSRestType>,
   ): this is NodePath<T & t.TSRestType>;
   isTSSatisfiesExpression<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TSSatisfiesExpression>,
   ): this is NodePath<T & t.TSSatisfiesExpression>;
   isTSStringKeyword<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TSStringKeyword>,
   ): this is NodePath<T & t.TSStringKeyword>;
   isTSSymbolKeyword<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TSSymbolKeyword>,
   ): this is NodePath<T & t.TSSymbolKeyword>;
   isTSThisType<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TSThisType>,
   ): this is NodePath<T & t.TSThisType>;
   isTSTupleType<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TSTupleType>,
   ): this is NodePath<T & t.TSTupleType>;
   isTSType<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TSType>,
   ): this is NodePath<T & t.TSType>;
   isTSTypeAliasDeclaration<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TSTypeAliasDeclaration>,
   ): this is NodePath<T & t.TSTypeAliasDeclaration>;
   isTSTypeAnnotation<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TSTypeAnnotation>,
   ): this is NodePath<T & t.TSTypeAnnotation>;
   isTSTypeAssertion<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TSTypeAssertion>,
   ): this is NodePath<T & t.TSTypeAssertion>;
   isTSTypeElement<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TSTypeElement>,
   ): this is NodePath<T & t.TSTypeElement>;
   isTSTypeLiteral<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TSTypeLiteral>,
   ): this is NodePath<T & t.TSTypeLiteral>;
   isTSTypeOperator<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TSTypeOperator>,
   ): this is NodePath<T & t.TSTypeOperator>;
   isTSTypeParameter<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TSTypeParameter>,
   ): this is NodePath<T & t.TSTypeParameter>;
   isTSTypeParameterDeclaration<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TSTypeParameterDeclaration>,
   ): this is NodePath<T & t.TSTypeParameterDeclaration>;
   isTSTypeParameterInstantiation<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TSTypeParameterInstantiation>,
   ): this is NodePath<T & t.TSTypeParameterInstantiation>;
   isTSTypePredicate<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TSTypePredicate>,
   ): this is NodePath<T & t.TSTypePredicate>;
   isTSTypeQuery<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TSTypeQuery>,
   ): this is NodePath<T & t.TSTypeQuery>;
   isTSTypeReference<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TSTypeReference>,
   ): this is NodePath<T & t.TSTypeReference>;
   isTSUndefinedKeyword<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TSUndefinedKeyword>,
   ): this is NodePath<T & t.TSUndefinedKeyword>;
   isTSUnionType<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TSUnionType>,
   ): this is NodePath<T & t.TSUnionType>;
   isTSUnknownKeyword<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TSUnknownKeyword>,
   ): this is NodePath<T & t.TSUnknownKeyword>;
   isTSVoidKeyword<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TSVoidKeyword>,
   ): this is NodePath<T & t.TSVoidKeyword>;
   isTaggedTemplateExpression<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TaggedTemplateExpression>,
   ): this is NodePath<T & t.TaggedTemplateExpression>;
   isTemplateElement<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TemplateElement>,
   ): this is NodePath<T & t.TemplateElement>;
   isTemplateLiteral<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TemplateLiteral>,
   ): this is NodePath<T & t.TemplateLiteral>;
   isTerminatorless<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.Terminatorless>,
   ): this is NodePath<T & t.Terminatorless>;
   isThisExpression<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.ThisExpression>,
   ): this is NodePath<T & t.ThisExpression>;
   isThisTypeAnnotation<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.ThisTypeAnnotation>,
   ): this is NodePath<T & t.ThisTypeAnnotation>;
   isThrowStatement<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.ThrowStatement>,
   ): this is NodePath<T & t.ThrowStatement>;
   isTopicReference<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TopicReference>,
   ): this is NodePath<T & t.TopicReference>;
   isTryStatement<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TryStatement>,
   ): this is NodePath<T & t.TryStatement>;
   isTupleExpression<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TupleExpression>,
   ): this is NodePath<T & t.TupleExpression>;
   isTupleTypeAnnotation<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TupleTypeAnnotation>,
   ): this is NodePath<T & t.TupleTypeAnnotation>;
   isTypeAlias<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TypeAlias>,
   ): this is NodePath<T & t.TypeAlias>;
   isTypeAnnotation<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TypeAnnotation>,
   ): this is NodePath<T & t.TypeAnnotation>;
   isTypeCastExpression<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TypeCastExpression>,
   ): this is NodePath<T & t.TypeCastExpression>;
   isTypeParameter<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TypeParameter>,
   ): this is NodePath<T & t.TypeParameter>;
   isTypeParameterDeclaration<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TypeParameterDeclaration>,
   ): this is NodePath<T & t.TypeParameterDeclaration>;
   isTypeParameterInstantiation<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TypeParameterInstantiation>,
   ): this is NodePath<T & t.TypeParameterInstantiation>;
   isTypeScript<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TypeScript>,
   ): this is NodePath<T & t.TypeScript>;
   isTypeofTypeAnnotation<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.TypeofTypeAnnotation>,
   ): this is NodePath<T & t.TypeofTypeAnnotation>;
   isUnaryExpression<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.UnaryExpression>,
   ): this is NodePath<T & t.UnaryExpression>;
   isUnaryLike<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.UnaryLike>,
   ): this is NodePath<T & t.UnaryLike>;
   isUnionTypeAnnotation<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.UnionTypeAnnotation>,
   ): this is NodePath<T & t.UnionTypeAnnotation>;
   isUpdateExpression<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.UpdateExpression>,
   ): this is NodePath<T & t.UpdateExpression>;
   isUserWhitespacable<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.UserWhitespacable>,
   ): this is NodePath<T & t.UserWhitespacable>;
   isV8IntrinsicIdentifier<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.V8IntrinsicIdentifier>,
   ): this is NodePath<T & t.V8IntrinsicIdentifier>;
   isVariableDeclaration<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.VariableDeclaration>,
   ): this is NodePath<T & t.VariableDeclaration>;
   isVariableDeclarator<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.VariableDeclarator>,
   ): this is NodePath<T & t.VariableDeclarator>;
   isVariance<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.Variance>,
   ): this is NodePath<T & t.Variance>;
   isVoidTypeAnnotation<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.VoidTypeAnnotation>,
   ): this is NodePath<T & t.VoidTypeAnnotation>;
   isWhile<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.While>,
   ): this is NodePath<T & t.While>;
   isWhileStatement<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.WhileStatement>,
   ): this is NodePath<T & t.WhileStatement>;
   isWithStatement<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.WithStatement>,
   ): this is NodePath<T & t.WithStatement>;
   isYieldExpression<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<t.YieldExpression>,
   ): this is NodePath<T & t.YieldExpression>;
 }
 
 export interface NodePathValidators
-  extends BaseNodePathValidators,
+  extends Omit<BaseNodePathValidators, keyof VirtualTypeNodePathValidators>,
     VirtualTypeNodePathValidators {}
diff --git a/packages/babel-traverse/src/path/lib/virtual-types-validator.ts b/packages/babel-traverse/src/path/lib/virtual-types-validator.ts
index 38f157a36008..6da221af4f21 100644
--- a/packages/babel-traverse/src/path/lib/virtual-types-validator.ts
+++ b/packages/babel-traverse/src/path/lib/virtual-types-validator.ts
@@ -26,66 +26,76 @@ import type * as t from "@babel/types";
 const { isCompatTag } = react;
 import type { VirtualTypeAliases } from "./virtual-types";
 
+type Opts<Obj> = Partial<{
+  [Prop in keyof Obj]: Obj[Prop] extends t.Node
+    ? t.Node
+    : Obj[Prop] extends t.Node[]
+    ? t.Node[]
+    : Obj[Prop];
+}>;
+
 export interface VirtualTypeNodePathValidators {
   isBindingIdentifier<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<VirtualTypeAliases["BindingIdentifier"]>,
   ): this is NodePath<T & VirtualTypeAliases["BindingIdentifier"]>;
-  isBlockScoped(opts?: object): boolean;
+  isBlockScoped(opts?: Opts<VirtualTypeAliases["BlockScoped"]>): boolean;
   /**
    * @deprecated
    */
   isExistentialTypeParam<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<VirtualTypeAliases["ExistentialTypeParam"]>,
   ): this is NodePath<T & VirtualTypeAliases["ExistentialTypeParam"]>;
   isExpression<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<VirtualTypeAliases["Expression"]>,
   ): this is NodePath<T & t.Expression>;
   isFlow<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<VirtualTypeAliases["Flow"]>,
   ): this is NodePath<T & t.Flow>;
   isForAwaitStatement<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<VirtualTypeAliases["ForAwaitStatement"]>,
   ): this is NodePath<T & VirtualTypeAliases["ForAwaitStatement"]>;
-  isGenerated(opts?: object): boolean;
+  isGenerated(opts?: VirtualTypeAliases["Generated"]): boolean;
   /**
    * @deprecated
    */
-  isNumericLiteralTypeAnnotation(opts?: object): void;
-  isPure(opts?: object): boolean;
-  isReferenced(opts?: object): boolean;
+  isNumericLiteralTypeAnnotation(
+    opts?: VirtualTypeAliases["NumericLiteralTypeAnnotation"],
+  ): void;
+  isPure(opts?: VirtualTypeAliases["Pure"]): boolean;
+  isReferenced(opts?: VirtualTypeAliases["Referenced"]): boolean;
   isReferencedIdentifier<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<VirtualTypeAliases["ReferencedIdentifier"]>,
   ): this is NodePath<T & VirtualTypeAliases["ReferencedIdentifier"]>;
   isReferencedMemberExpression<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<VirtualTypeAliases["ReferencedMemberExpression"]>,
   ): this is NodePath<T & VirtualTypeAliases["ReferencedMemberExpression"]>;
   isRestProperty<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<VirtualTypeAliases["RestProperty"]>,
   ): this is NodePath<T & t.RestProperty>;
   isScope<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<VirtualTypeAliases["Scope"]>,
   ): this is NodePath<T & VirtualTypeAliases["Scope"]>;
   isSpreadProperty<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<VirtualTypeAliases["SpreadProperty"]>,
   ): this is NodePath<T & t.SpreadProperty>;
   isStatement<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<VirtualTypeAliases["Statement"]>,
   ): this is NodePath<T & t.Statement>;
-  isUser(opts?: object): boolean;
+  isUser(opts?: VirtualTypeAliases["User"]): boolean;
   isVar<T extends t.Node>(
     this: NodePath<T>,
-    opts?: object,
+    opts?: Opts<VirtualTypeAliases["Var"]>,
   ): this is NodePath<T & VirtualTypeAliases["Var"]>;
 }
 
@@ -201,14 +211,23 @@ export function isForAwaitStatement(this: NodePath): boolean {
   return isForOfStatement(this.node, { await: true });
 }
 
-export function isExistentialTypeParam(this: NodePath): void {
-  throw new Error(
-    "`path.isExistentialTypeParam` has been renamed to `path.isExistsTypeAnnotation()` in Babel 7.",
-  );
-}
-
-export function isNumericLiteralTypeAnnotation(this: NodePath): void {
-  throw new Error(
-    "`path.isNumericLiteralTypeAnnotation()` has been renamed to `path.isNumberLiteralTypeAnnotation()` in Babel 7.",
-  );
+if (!process.env.BABEL_8_BREAKING) {
+  if (!USE_ESM) {
+    // eslint-disable-next-line no-restricted-globals
+    exports.isExistentialTypeParam = function isExistentialTypeParam(
+      this: NodePath,
+    ): void {
+      throw new Error(
+        "`path.isExistentialTypeParam` has been renamed to `path.isExistsTypeAnnotation()` in Babel 7.",
+      );
+    };
+
+    // eslint-disable-next-line no-restricted-globals
+    exports.isNumericLiteralTypeAnnotation =
+      function isNumericLiteralTypeAnnotation(this: NodePath): void {
+        throw new Error(
+          "`path.isNumericLiteralTypeAnnotation()` has been renamed to `path.isNumberLiteralTypeAnnotation()` in Babel 7.",
+        );
+      };
+  }
 }
diff --git a/packages/babel-traverse/src/visitors.ts b/packages/babel-traverse/src/visitors.ts
index de38c6e19714..c5fc89621021 100644
--- a/packages/babel-traverse/src/visitors.ts
+++ b/packages/babel-traverse/src/visitors.ts
@@ -331,6 +331,7 @@ function ensureCallbackArrays(obj: Visitor) {
 
 function wrapCheck(nodeType: VIRTUAL_TYPES, fn: Function) {
   const newFn = function (this: unknown, path: NodePath) {
+    // @ts-expect-error: Expression produces a union type that is too complex to represent.
     if (path[`is${nodeType}`]()) {
       return fn.apply(this, arguments);
     }
diff --git a/packages/babel-types/scripts/generators/validators.js b/packages/babel-types/scripts/generators/validators.js
index 870423f5bc9b..95577fc18cb1 100644
--- a/packages/babel-types/scripts/generators/validators.js
+++ b/packages/babel-types/scripts/generators/validators.js
@@ -81,12 +81,12 @@ import shallowEqual from "../../utils/shallowEqual";
 import type * as t from "../..";
 import deprecationWarning from "../../utils/deprecationWarning";
 
-type Opts<Object> = Partial<{
-  [Prop in keyof Object]: Object[Prop] extends t.Node
-    ? t.Node | Object[Prop]
-    : Object[Prop] extends t.Node[]
-    ? t.Node[] | Object[Prop]
-    : Object[Prop];
+type Opts<Obj> = Partial<{
+  [Prop in keyof Obj]: Obj[Prop] extends t.Node
+    ? t.Node
+    : Obj[Prop] extends t.Node[]
+    ? t.Node[]
+    : Obj[Prop];
 }>;
 
 `;
diff --git a/packages/babel-types/src/validators/generated/index.ts b/packages/babel-types/src/validators/generated/index.ts
index 0933f7fa883d..4ea3fb808ff9 100644
--- a/packages/babel-types/src/validators/generated/index.ts
+++ b/packages/babel-types/src/validators/generated/index.ts
@@ -9,12 +9,12 @@ import shallowEqual from "../../utils/shallowEqual";
 import type * as t from "../..";
 import deprecationWarning from "../../utils/deprecationWarning";
 
-type Opts<Object> = Partial<{
-  [Prop in keyof Object]: Object[Prop] extends t.Node
-    ? t.Node | Object[Prop]
-    : Object[Prop] extends t.Node[]
-    ? t.Node[] | Object[Prop]
-    : Object[Prop];
+type Opts<Obj> = Partial<{
+  [Prop in keyof Obj]: Obj[Prop] extends t.Node
+    ? t.Node
+    : Obj[Prop] extends t.Node[]
+    ? t.Node[]
+    : Obj[Prop];
 }>;
 
 export function isArrayExpression(