From 680f69fa09782b74aa62516ba1f5e76a72daba79 Mon Sep 17 00:00:00 2001
From: liuxingbaoyu <30521560+liuxingbaoyu@users.noreply.github.com>
Date: Thu, 6 Apr 2023 00:15:33 +0800
Subject: [PATCH 1/6] improve

---
 .../scripts/generators/validators.js          | 35 +++++++++++++------
 .../src/validators/generated/index.ts         | 15 ++++++++
 2 files changed, 40 insertions(+), 10 deletions(-)

diff --git a/packages/babel-types/scripts/generators/validators.js b/packages/babel-types/scripts/generators/validators.js
index 380043589c89..c165f763842e 100644
--- a/packages/babel-types/scripts/generators/validators.js
+++ b/packages/babel-types/scripts/generators/validators.js
@@ -8,6 +8,8 @@ import {
   VISITOR_KEYS,
 } from "../../lib/index.js";
 
+const BABEL8 = !!process.env.BABEL_8_BREAKING;
+
 const has = Function.call.bind(Object.prototype.hasOwnProperty);
 
 function buildCases(arr) {
@@ -31,7 +33,7 @@ function addIsHelper(type, aliasKeys, deprecated) {
   if (placeholderTypes.length > 0) {
     cases += `
     case "Placeholder":
-      switch ((node as t.Placeholder).expectedNode) {
+      switch (${BABEL8 ? "node" : "(node as t.Placeholder)"}.expectedNode) {
         ${buildCases(placeholderTypes)}
         default:
           return false;
@@ -44,19 +46,25 @@ function addIsHelper(type, aliasKeys, deprecated) {
       ? `node is t.${type}`
       : "boolean";
 
-  return `export function is${type}(node: object | null | undefined, opts?: object | null): ${result} {
+  return `export function is${type}(${
+    BABEL8
+      ? `node: t.Node | null | undefined, opts?: Partial<t.${type}> | null`
+      : "node: object | null | undefined, opts?: object | null"
+  }): ${result} {
     ${deprecated || ""}
     if (!node) return false;
 
     ${
       cases
         ? `
-          switch((node as t.Node).type){
+          switch(${BABEL8 ? "node" : "(node as t.Node)"}.type){
             ${cases}
             default:
               return false;
           }`
-        : `if ((node as t.Node).type !== ${targetType}) return false;`
+        : `if (${
+            BABEL8 ? "node" : "(node as t.Node)"
+          }.type !== ${targetType}) return false;`
     }
 
     return opts == null || shallowEqual(node, opts);
@@ -87,16 +95,23 @@ import deprecationWarning from "../../utils/deprecationWarning";
     });
 
   Object.keys(DEPRECATED_KEYS).forEach(type => {
-    output += addIsHelper(
-      type,
-      null,
-      `deprecationWarning("is${type}", "is${DEPRECATED_KEYS[type]}")`
-    );
+    const newType = DEPRECATED_KEYS[type];
+    output += `/**
+ * @deprecated Use \`is${newType}\`
+ */
+${addIsHelper(type, null, `deprecationWarning("is${type}", "is${newType}")`)}`;
   });
 
   Object.keys(DEPRECATED_ALIASES).forEach(type => {
     const newType = DEPRECATED_ALIASES[type];
-    output += `export function is${type}(node: object | null | undefined, opts?: object | null): node is t.${newType} {
+    output += `/**
+ * @deprecated Use \`is${newType}\`
+ */
+export function is${type}(${
+      BABEL8
+        ? `node: t.Node | null | undefined, opts?: Partial<t.${type}> | null`
+        : "node: object | null | undefined, opts?: object | null"
+    }): node is t.${newType} {
   deprecationWarning("is${type}", "is${newType}");
   return is${newType}(node, opts);
 }
diff --git a/packages/babel-types/src/validators/generated/index.ts b/packages/babel-types/src/validators/generated/index.ts
index 13431217a795..0ab6a41fd0a7 100644
--- a/packages/babel-types/src/validators/generated/index.ts
+++ b/packages/babel-types/src/validators/generated/index.ts
@@ -3954,6 +3954,9 @@ export function isTSBaseType(
 
   return opts == null || shallowEqual(node, opts);
 }
+/**
+ * @deprecated Use `isNumericLiteral`
+ */
 export function isNumberLiteral(
   node: object | null | undefined,
   opts?: object | null,
@@ -3965,6 +3968,9 @@ export function isNumberLiteral(
 
   return opts == null || shallowEqual(node, opts);
 }
+/**
+ * @deprecated Use `isRegExpLiteral`
+ */
 export function isRegexLiteral(
   node: object | null | undefined,
   opts?: object | null,
@@ -3976,6 +3982,9 @@ export function isRegexLiteral(
 
   return opts == null || shallowEqual(node, opts);
 }
+/**
+ * @deprecated Use `isRestElement`
+ */
 export function isRestProperty(
   node: object | null | undefined,
   opts?: object | null,
@@ -3987,6 +3996,9 @@ export function isRestProperty(
 
   return opts == null || shallowEqual(node, opts);
 }
+/**
+ * @deprecated Use `isSpreadElement`
+ */
 export function isSpreadProperty(
   node: object | null | undefined,
   opts?: object | null,
@@ -3998,6 +4010,9 @@ export function isSpreadProperty(
 
   return opts == null || shallowEqual(node, opts);
 }
+/**
+ * @deprecated Use `isImportOrExportDeclaration`
+ */
 export function isModuleDeclaration(
   node: object | null | undefined,
   opts?: object | null,

From a5275d02e087dbca9d67aea73c94110e983b03eb Mon Sep 17 00:00:00 2001
From: liuxingbaoyu <30521560+liuxingbaoyu@users.noreply.github.com>
Date: Fri, 7 Apr 2023 02:11:13 +0800
Subject: [PATCH 2/6] fix

---
 .../babel-types/scripts/generators/validators.js   | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

diff --git a/packages/babel-types/scripts/generators/validators.js b/packages/babel-types/scripts/generators/validators.js
index c165f763842e..d77fe3b0a952 100644
--- a/packages/babel-types/scripts/generators/validators.js
+++ b/packages/babel-types/scripts/generators/validators.js
@@ -48,7 +48,7 @@ function addIsHelper(type, aliasKeys, deprecated) {
 
   return `export function is${type}(${
     BABEL8
-      ? `node: t.Node | null | undefined, opts?: Partial<t.${type}> | null`
+      ? `node: t.Node | null | undefined, opts?: Opts<t.${type}> | null`
       : "node: object | null | undefined, opts?: object | null"
   }): ${result} {
     ${deprecated || ""}
@@ -81,6 +81,16 @@ import shallowEqual from "../../utils/shallowEqual";
 import type * as t from "../..";
 import deprecationWarning from "../../utils/deprecationWarning";
 \n`;
+  if (BABEL8) {
+    output += `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];
+}>;
+\n`;
+  }
 
   Object.keys(VISITOR_KEYS).forEach(type => {
     output += addIsHelper(type);
@@ -109,7 +119,7 @@ ${addIsHelper(type, null, `deprecationWarning("is${type}", "is${newType}")`)}`;
  */
 export function is${type}(${
       BABEL8
-        ? `node: t.Node | null | undefined, opts?: Partial<t.${type}> | null`
+        ? `node: t.Node | null | undefined, opts?: Opts<t.${type}> | null`
         : "node: object | null | undefined, opts?: object | null"
     }): node is t.${newType} {
   deprecationWarning("is${type}", "is${newType}");

From 3849564962952241c9fcf1f0687ec32ef7217ad5 Mon Sep 17 00:00:00 2001
From: liuxingbaoyu <30521560+liuxingbaoyu@users.noreply.github.com>
Date: Fri, 7 Apr 2023 02:23:44 +0800
Subject: [PATCH 3/6] fix bug

---
 .../src/index.ts                                           | 2 +-
 .../babel-plugin-transform-react-jsx/src/create-plugin.ts  | 7 ++++---
 packages/babel-traverse/src/path/introspection.ts          | 2 +-
 3 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/packages/babel-plugin-transform-react-constant-elements/src/index.ts b/packages/babel-plugin-transform-react-constant-elements/src/index.ts
index 27e8b1e6726b..95c6763ffdd1 100644
--- a/packages/babel-plugin-transform-react-constant-elements/src/index.ts
+++ b/packages/babel-plugin-transform-react-constant-elements/src/index.ts
@@ -153,7 +153,7 @@ export default declare((api, options: Options) => {
           skip();
           return;
         }
-      } else if (t.isIdentifier(expressionResult.deopt)) {
+      } else if (expressionResult.deopt?.isIdentifier()) {
         // It's safe to hoist here if the deopt reason is an identifier (e.g. func param).
         // The hoister will take care of how high up it can be hoisted.
         return;
diff --git a/packages/babel-plugin-transform-react-jsx/src/create-plugin.ts b/packages/babel-plugin-transform-react-jsx/src/create-plugin.ts
index aa8a809ffa16..e1f71b4257f4 100644
--- a/packages/babel-plugin-transform-react-jsx/src/create-plugin.ts
+++ b/packages/babel-plugin-transform-react-jsx/src/create-plugin.ts
@@ -768,10 +768,11 @@ You can set \`throwIfNamespace: false\` to bypass this warning.`,
       const found = Object.create(null);
 
       for (const attr of attribs) {
+        const { node } = attr;
         const name =
-          t.isJSXAttribute(attr) &&
-          t.isJSXIdentifier(attr.name) &&
-          attr.name.name;
+          t.isJSXAttribute(node) &&
+          t.isJSXIdentifier(node.name) &&
+          node.name.name;
 
         if (
           runtime === "automatic" &&
diff --git a/packages/babel-traverse/src/path/introspection.ts b/packages/babel-traverse/src/path/introspection.ts
index 8367b844aebf..176867f409b0 100644
--- a/packages/babel-traverse/src/path/introspection.ts
+++ b/packages/babel-traverse/src/path/introspection.ts
@@ -176,7 +176,7 @@ export function isCompletionRecord(
 export function isStatementOrBlock(this: NodePath): boolean {
   if (
     this.parentPath.isLabeledStatement() ||
-    isBlockStatement(this.container)
+    isBlockStatement(this.container as t.Node)
   ) {
     return false;
   } else {

From be4dc337d7cddb01138b34209d2102bba86022d3 Mon Sep 17 00:00:00 2001
From: liuxingbaoyu <30521560+liuxingbaoyu@users.noreply.github.com>
Date: Fri, 7 Apr 2023 02:40:52 +0800
Subject: [PATCH 4/6] fix

---
 packages/babel-types/scripts/generators/validators.js | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/packages/babel-types/scripts/generators/validators.js b/packages/babel-types/scripts/generators/validators.js
index d77fe3b0a952..796ad088cbc0 100644
--- a/packages/babel-types/scripts/generators/validators.js
+++ b/packages/babel-types/scripts/generators/validators.js
@@ -8,7 +8,10 @@ import {
   VISITOR_KEYS,
 } from "../../lib/index.js";
 
-const BABEL8 = !!process.env.BABEL_8_BREAKING;
+function bool(value) {
+  return value && value !== "false" && value !== "0";
+}
+const BABEL8 = bool(process.env.BABEL_8_BREAKING);
 
 const has = Function.call.bind(Object.prototype.hasOwnProperty);
 

From b6d0636d22bc5194d2506dd8c4af7d0617e1b940 Mon Sep 17 00:00:00 2001
From: liuxingbaoyu <30521560+liuxingbaoyu@users.noreply.github.com>
Date: Sat, 20 May 2023 20:32:05 +0800
Subject: [PATCH 5/6] review

---
 .../scripts/generators/validators.js          |   34 +-
 .../src/validators/generated/index.ts         | 1852 +++++++++--------
 2 files changed, 939 insertions(+), 947 deletions(-)

diff --git a/packages/babel-types/scripts/generators/validators.js b/packages/babel-types/scripts/generators/validators.js
index 796ad088cbc0..0dc7d5ea447a 100644
--- a/packages/babel-types/scripts/generators/validators.js
+++ b/packages/babel-types/scripts/generators/validators.js
@@ -8,11 +8,6 @@ import {
   VISITOR_KEYS,
 } from "../../lib/index.js";
 
-function bool(value) {
-  return value && value !== "false" && value !== "0";
-}
-const BABEL8 = bool(process.env.BABEL_8_BREAKING);
-
 const has = Function.call.bind(Object.prototype.hasOwnProperty);
 
 function buildCases(arr) {
@@ -36,7 +31,7 @@ function addIsHelper(type, aliasKeys, deprecated) {
   if (placeholderTypes.length > 0) {
     cases += `
     case "Placeholder":
-      switch (${BABEL8 ? "node" : "(node as t.Placeholder)"}.expectedNode) {
+      switch (node.expectedNode) {
         ${buildCases(placeholderTypes)}
         default:
           return false;
@@ -49,25 +44,19 @@ function addIsHelper(type, aliasKeys, deprecated) {
       ? `node is t.${type}`
       : "boolean";
 
-  return `export function is${type}(${
-    BABEL8
-      ? `node: t.Node | null | undefined, opts?: Opts<t.${type}> | null`
-      : "node: object | null | undefined, opts?: object | null"
-  }): ${result} {
+  return `export function is${type}(node: t.Node | null | undefined, opts?: Opts<t.${type}> | null): ${result} {
     ${deprecated || ""}
     if (!node) return false;
 
     ${
       cases
         ? `
-          switch(${BABEL8 ? "node" : "(node as t.Node)"}.type){
+          switch(node.type){
             ${cases}
             default:
               return false;
           }`
-        : `if (${
-            BABEL8 ? "node" : "(node as t.Node)"
-          }.type !== ${targetType}) return false;`
+        : `if (node.type !== ${targetType}) return false;`
     }
 
     return opts == null || shallowEqual(node, opts);
@@ -83,17 +72,16 @@ export default function generateValidators() {
 import shallowEqual from "../../utils/shallowEqual";
 import type * as t from "../..";
 import deprecationWarning from "../../utils/deprecationWarning";
-\n`;
-  if (BABEL8) {
-    output += `type Opts<Object> = Partial<{
+
+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];
 }>;
-\n`;
-  }
+
+`;
 
   Object.keys(VISITOR_KEYS).forEach(type => {
     output += addIsHelper(type);
@@ -120,11 +108,7 @@ ${addIsHelper(type, null, `deprecationWarning("is${type}", "is${newType}")`)}`;
     output += `/**
  * @deprecated Use \`is${newType}\`
  */
-export function is${type}(${
-      BABEL8
-        ? `node: t.Node | null | undefined, opts?: Opts<t.${type}> | null`
-        : "node: object | null | undefined, opts?: object | null"
-    }): node is t.${newType} {
+export function is${type}(node: t.Node | null | undefined, opts?: Opts<t.${type}> | null): node is t.${newType} {
   deprecationWarning("is${type}", "is${newType}");
   return is${newType}(node, opts);
 }
diff --git a/packages/babel-types/src/validators/generated/index.ts b/packages/babel-types/src/validators/generated/index.ts
index 0ab6a41fd0a7..38a3c73a48d5 100644
--- a/packages/babel-types/src/validators/generated/index.ts
+++ b/packages/babel-types/src/validators/generated/index.ts
@@ -6,2503 +6,2511 @@ 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];
+}>;
+
 export function isArrayExpression(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.ArrayExpression> | null,
 ): node is t.ArrayExpression {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "ArrayExpression") return false;
+  if (node.type !== "ArrayExpression") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isAssignmentExpression(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.AssignmentExpression> | null,
 ): node is t.AssignmentExpression {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "AssignmentExpression") return false;
+  if (node.type !== "AssignmentExpression") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isBinaryExpression(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.BinaryExpression> | null,
 ): node is t.BinaryExpression {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "BinaryExpression") return false;
+  if (node.type !== "BinaryExpression") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isInterpreterDirective(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.InterpreterDirective> | null,
 ): node is t.InterpreterDirective {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "InterpreterDirective") return false;
+  if (node.type !== "InterpreterDirective") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isDirective(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.Directive> | null,
 ): node is t.Directive {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "Directive") return false;
+  if (node.type !== "Directive") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isDirectiveLiteral(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.DirectiveLiteral> | null,
 ): node is t.DirectiveLiteral {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "DirectiveLiteral") return false;
+  if (node.type !== "DirectiveLiteral") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isBlockStatement(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.BlockStatement> | null,
 ): node is t.BlockStatement {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "BlockStatement") return false;
+  if (node.type !== "BlockStatement") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isBreakStatement(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.BreakStatement> | null,
 ): node is t.BreakStatement {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "BreakStatement") return false;
+  if (node.type !== "BreakStatement") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isCallExpression(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.CallExpression> | null,
 ): node is t.CallExpression {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "CallExpression") return false;
+  if (node.type !== "CallExpression") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isCatchClause(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.CatchClause> | null,
 ): node is t.CatchClause {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "CatchClause") return false;
+  if (node.type !== "CatchClause") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isConditionalExpression(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.ConditionalExpression> | null,
 ): node is t.ConditionalExpression {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "ConditionalExpression") return false;
+  if (node.type !== "ConditionalExpression") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isContinueStatement(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.ContinueStatement> | null,
 ): node is t.ContinueStatement {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "ContinueStatement") return false;
+  if (node.type !== "ContinueStatement") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isDebuggerStatement(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.DebuggerStatement> | null,
 ): node is t.DebuggerStatement {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "DebuggerStatement") return false;
+  if (node.type !== "DebuggerStatement") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isDoWhileStatement(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.DoWhileStatement> | null,
 ): node is t.DoWhileStatement {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "DoWhileStatement") return false;
+  if (node.type !== "DoWhileStatement") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isEmptyStatement(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.EmptyStatement> | null,
 ): node is t.EmptyStatement {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "EmptyStatement") return false;
+  if (node.type !== "EmptyStatement") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isExpressionStatement(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.ExpressionStatement> | null,
 ): node is t.ExpressionStatement {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "ExpressionStatement") return false;
+  if (node.type !== "ExpressionStatement") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isFile(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.File> | null,
 ): node is t.File {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "File") return false;
+  if (node.type !== "File") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isForInStatement(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.ForInStatement> | null,
 ): node is t.ForInStatement {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "ForInStatement") return false;
+  if (node.type !== "ForInStatement") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isForStatement(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.ForStatement> | null,
 ): node is t.ForStatement {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "ForStatement") return false;
+  if (node.type !== "ForStatement") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isFunctionDeclaration(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.FunctionDeclaration> | null,
 ): node is t.FunctionDeclaration {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "FunctionDeclaration") return false;
+  if (node.type !== "FunctionDeclaration") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isFunctionExpression(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.FunctionExpression> | null,
 ): node is t.FunctionExpression {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "FunctionExpression") return false;
+  if (node.type !== "FunctionExpression") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isIdentifier(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.Identifier> | null,
 ): node is t.Identifier {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "Identifier") return false;
+  if (node.type !== "Identifier") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isIfStatement(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.IfStatement> | null,
 ): node is t.IfStatement {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "IfStatement") return false;
+  if (node.type !== "IfStatement") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isLabeledStatement(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.LabeledStatement> | null,
 ): node is t.LabeledStatement {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "LabeledStatement") return false;
+  if (node.type !== "LabeledStatement") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isStringLiteral(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.StringLiteral> | null,
 ): node is t.StringLiteral {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "StringLiteral") return false;
+  if (node.type !== "StringLiteral") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isNumericLiteral(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.NumericLiteral> | null,
 ): node is t.NumericLiteral {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "NumericLiteral") return false;
+  if (node.type !== "NumericLiteral") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isNullLiteral(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.NullLiteral> | null,
 ): node is t.NullLiteral {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "NullLiteral") return false;
+  if (node.type !== "NullLiteral") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isBooleanLiteral(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.BooleanLiteral> | null,
 ): node is t.BooleanLiteral {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "BooleanLiteral") return false;
+  if (node.type !== "BooleanLiteral") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isRegExpLiteral(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.RegExpLiteral> | null,
 ): node is t.RegExpLiteral {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "RegExpLiteral") return false;
+  if (node.type !== "RegExpLiteral") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isLogicalExpression(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.LogicalExpression> | null,
 ): node is t.LogicalExpression {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "LogicalExpression") return false;
+  if (node.type !== "LogicalExpression") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isMemberExpression(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.MemberExpression> | null,
 ): node is t.MemberExpression {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "MemberExpression") return false;
+  if (node.type !== "MemberExpression") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isNewExpression(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.NewExpression> | null,
 ): node is t.NewExpression {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "NewExpression") return false;
+  if (node.type !== "NewExpression") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isProgram(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.Program> | null,
 ): node is t.Program {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "Program") return false;
+  if (node.type !== "Program") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isObjectExpression(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.ObjectExpression> | null,
 ): node is t.ObjectExpression {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "ObjectExpression") return false;
+  if (node.type !== "ObjectExpression") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isObjectMethod(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.ObjectMethod> | null,
 ): node is t.ObjectMethod {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "ObjectMethod") return false;
+  if (node.type !== "ObjectMethod") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isObjectProperty(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.ObjectProperty> | null,
 ): node is t.ObjectProperty {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "ObjectProperty") return false;
+  if (node.type !== "ObjectProperty") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isRestElement(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.RestElement> | null,
 ): node is t.RestElement {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "RestElement") return false;
+  if (node.type !== "RestElement") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isReturnStatement(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.ReturnStatement> | null,
 ): node is t.ReturnStatement {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "ReturnStatement") return false;
+  if (node.type !== "ReturnStatement") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isSequenceExpression(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.SequenceExpression> | null,
 ): node is t.SequenceExpression {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "SequenceExpression") return false;
+  if (node.type !== "SequenceExpression") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isParenthesizedExpression(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.ParenthesizedExpression> | null,
 ): node is t.ParenthesizedExpression {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "ParenthesizedExpression") return false;
+  if (node.type !== "ParenthesizedExpression") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isSwitchCase(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.SwitchCase> | null,
 ): node is t.SwitchCase {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "SwitchCase") return false;
+  if (node.type !== "SwitchCase") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isSwitchStatement(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.SwitchStatement> | null,
 ): node is t.SwitchStatement {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "SwitchStatement") return false;
+  if (node.type !== "SwitchStatement") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isThisExpression(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.ThisExpression> | null,
 ): node is t.ThisExpression {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "ThisExpression") return false;
+  if (node.type !== "ThisExpression") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isThrowStatement(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.ThrowStatement> | null,
 ): node is t.ThrowStatement {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "ThrowStatement") return false;
+  if (node.type !== "ThrowStatement") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTryStatement(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TryStatement> | null,
 ): node is t.TryStatement {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TryStatement") return false;
+  if (node.type !== "TryStatement") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isUnaryExpression(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.UnaryExpression> | null,
 ): node is t.UnaryExpression {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "UnaryExpression") return false;
+  if (node.type !== "UnaryExpression") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isUpdateExpression(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.UpdateExpression> | null,
 ): node is t.UpdateExpression {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "UpdateExpression") return false;
+  if (node.type !== "UpdateExpression") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isVariableDeclaration(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.VariableDeclaration> | null,
 ): node is t.VariableDeclaration {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "VariableDeclaration") return false;
+  if (node.type !== "VariableDeclaration") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isVariableDeclarator(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.VariableDeclarator> | null,
 ): node is t.VariableDeclarator {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "VariableDeclarator") return false;
+  if (node.type !== "VariableDeclarator") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isWhileStatement(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.WhileStatement> | null,
 ): node is t.WhileStatement {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "WhileStatement") return false;
+  if (node.type !== "WhileStatement") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isWithStatement(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.WithStatement> | null,
 ): node is t.WithStatement {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "WithStatement") return false;
+  if (node.type !== "WithStatement") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isAssignmentPattern(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.AssignmentPattern> | null,
 ): node is t.AssignmentPattern {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "AssignmentPattern") return false;
+  if (node.type !== "AssignmentPattern") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isArrayPattern(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.ArrayPattern> | null,
 ): node is t.ArrayPattern {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "ArrayPattern") return false;
+  if (node.type !== "ArrayPattern") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isArrowFunctionExpression(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.ArrowFunctionExpression> | null,
 ): node is t.ArrowFunctionExpression {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "ArrowFunctionExpression") return false;
+  if (node.type !== "ArrowFunctionExpression") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isClassBody(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.ClassBody> | null,
 ): node is t.ClassBody {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "ClassBody") return false;
+  if (node.type !== "ClassBody") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isClassExpression(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.ClassExpression> | null,
 ): node is t.ClassExpression {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "ClassExpression") return false;
+  if (node.type !== "ClassExpression") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isClassDeclaration(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.ClassDeclaration> | null,
 ): node is t.ClassDeclaration {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "ClassDeclaration") return false;
+  if (node.type !== "ClassDeclaration") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isExportAllDeclaration(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.ExportAllDeclaration> | null,
 ): node is t.ExportAllDeclaration {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "ExportAllDeclaration") return false;
+  if (node.type !== "ExportAllDeclaration") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isExportDefaultDeclaration(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.ExportDefaultDeclaration> | null,
 ): node is t.ExportDefaultDeclaration {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "ExportDefaultDeclaration") return false;
+  if (node.type !== "ExportDefaultDeclaration") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isExportNamedDeclaration(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.ExportNamedDeclaration> | null,
 ): node is t.ExportNamedDeclaration {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "ExportNamedDeclaration") return false;
+  if (node.type !== "ExportNamedDeclaration") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isExportSpecifier(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.ExportSpecifier> | null,
 ): node is t.ExportSpecifier {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "ExportSpecifier") return false;
+  if (node.type !== "ExportSpecifier") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isForOfStatement(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.ForOfStatement> | null,
 ): node is t.ForOfStatement {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "ForOfStatement") return false;
+  if (node.type !== "ForOfStatement") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isImportDeclaration(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.ImportDeclaration> | null,
 ): node is t.ImportDeclaration {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "ImportDeclaration") return false;
+  if (node.type !== "ImportDeclaration") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isImportDefaultSpecifier(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.ImportDefaultSpecifier> | null,
 ): node is t.ImportDefaultSpecifier {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "ImportDefaultSpecifier") return false;
+  if (node.type !== "ImportDefaultSpecifier") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isImportNamespaceSpecifier(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.ImportNamespaceSpecifier> | null,
 ): node is t.ImportNamespaceSpecifier {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "ImportNamespaceSpecifier") return false;
+  if (node.type !== "ImportNamespaceSpecifier") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isImportSpecifier(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.ImportSpecifier> | null,
 ): node is t.ImportSpecifier {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "ImportSpecifier") return false;
+  if (node.type !== "ImportSpecifier") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isMetaProperty(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.MetaProperty> | null,
 ): node is t.MetaProperty {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "MetaProperty") return false;
+  if (node.type !== "MetaProperty") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isClassMethod(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.ClassMethod> | null,
 ): node is t.ClassMethod {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "ClassMethod") return false;
+  if (node.type !== "ClassMethod") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isObjectPattern(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.ObjectPattern> | null,
 ): node is t.ObjectPattern {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "ObjectPattern") return false;
+  if (node.type !== "ObjectPattern") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isSpreadElement(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.SpreadElement> | null,
 ): node is t.SpreadElement {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "SpreadElement") return false;
+  if (node.type !== "SpreadElement") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isSuper(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.Super> | null,
 ): node is t.Super {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "Super") return false;
+  if (node.type !== "Super") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTaggedTemplateExpression(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TaggedTemplateExpression> | null,
 ): node is t.TaggedTemplateExpression {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TaggedTemplateExpression") return false;
+  if (node.type !== "TaggedTemplateExpression") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTemplateElement(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TemplateElement> | null,
 ): node is t.TemplateElement {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TemplateElement") return false;
+  if (node.type !== "TemplateElement") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTemplateLiteral(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TemplateLiteral> | null,
 ): node is t.TemplateLiteral {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TemplateLiteral") return false;
+  if (node.type !== "TemplateLiteral") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isYieldExpression(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.YieldExpression> | null,
 ): node is t.YieldExpression {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "YieldExpression") return false;
+  if (node.type !== "YieldExpression") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isAwaitExpression(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.AwaitExpression> | null,
 ): node is t.AwaitExpression {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "AwaitExpression") return false;
+  if (node.type !== "AwaitExpression") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isImport(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.Import> | null,
 ): node is t.Import {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "Import") return false;
+  if (node.type !== "Import") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isBigIntLiteral(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.BigIntLiteral> | null,
 ): node is t.BigIntLiteral {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "BigIntLiteral") return false;
+  if (node.type !== "BigIntLiteral") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isExportNamespaceSpecifier(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.ExportNamespaceSpecifier> | null,
 ): node is t.ExportNamespaceSpecifier {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "ExportNamespaceSpecifier") return false;
+  if (node.type !== "ExportNamespaceSpecifier") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isOptionalMemberExpression(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.OptionalMemberExpression> | null,
 ): node is t.OptionalMemberExpression {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "OptionalMemberExpression") return false;
+  if (node.type !== "OptionalMemberExpression") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isOptionalCallExpression(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.OptionalCallExpression> | null,
 ): node is t.OptionalCallExpression {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "OptionalCallExpression") return false;
+  if (node.type !== "OptionalCallExpression") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isClassProperty(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.ClassProperty> | null,
 ): node is t.ClassProperty {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "ClassProperty") return false;
+  if (node.type !== "ClassProperty") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isClassAccessorProperty(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.ClassAccessorProperty> | null,
 ): node is t.ClassAccessorProperty {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "ClassAccessorProperty") return false;
+  if (node.type !== "ClassAccessorProperty") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isClassPrivateProperty(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.ClassPrivateProperty> | null,
 ): node is t.ClassPrivateProperty {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "ClassPrivateProperty") return false;
+  if (node.type !== "ClassPrivateProperty") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isClassPrivateMethod(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.ClassPrivateMethod> | null,
 ): node is t.ClassPrivateMethod {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "ClassPrivateMethod") return false;
+  if (node.type !== "ClassPrivateMethod") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isPrivateName(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.PrivateName> | null,
 ): node is t.PrivateName {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "PrivateName") return false;
+  if (node.type !== "PrivateName") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isStaticBlock(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.StaticBlock> | null,
 ): node is t.StaticBlock {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "StaticBlock") return false;
+  if (node.type !== "StaticBlock") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isAnyTypeAnnotation(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.AnyTypeAnnotation> | null,
 ): node is t.AnyTypeAnnotation {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "AnyTypeAnnotation") return false;
+  if (node.type !== "AnyTypeAnnotation") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isArrayTypeAnnotation(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.ArrayTypeAnnotation> | null,
 ): node is t.ArrayTypeAnnotation {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "ArrayTypeAnnotation") return false;
+  if (node.type !== "ArrayTypeAnnotation") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isBooleanTypeAnnotation(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.BooleanTypeAnnotation> | null,
 ): node is t.BooleanTypeAnnotation {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "BooleanTypeAnnotation") return false;
+  if (node.type !== "BooleanTypeAnnotation") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isBooleanLiteralTypeAnnotation(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.BooleanLiteralTypeAnnotation> | null,
 ): node is t.BooleanLiteralTypeAnnotation {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "BooleanLiteralTypeAnnotation") return false;
+  if (node.type !== "BooleanLiteralTypeAnnotation") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isNullLiteralTypeAnnotation(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.NullLiteralTypeAnnotation> | null,
 ): node is t.NullLiteralTypeAnnotation {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "NullLiteralTypeAnnotation") return false;
+  if (node.type !== "NullLiteralTypeAnnotation") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isClassImplements(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.ClassImplements> | null,
 ): node is t.ClassImplements {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "ClassImplements") return false;
+  if (node.type !== "ClassImplements") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isDeclareClass(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.DeclareClass> | null,
 ): node is t.DeclareClass {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "DeclareClass") return false;
+  if (node.type !== "DeclareClass") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isDeclareFunction(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.DeclareFunction> | null,
 ): node is t.DeclareFunction {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "DeclareFunction") return false;
+  if (node.type !== "DeclareFunction") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isDeclareInterface(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.DeclareInterface> | null,
 ): node is t.DeclareInterface {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "DeclareInterface") return false;
+  if (node.type !== "DeclareInterface") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isDeclareModule(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.DeclareModule> | null,
 ): node is t.DeclareModule {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "DeclareModule") return false;
+  if (node.type !== "DeclareModule") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isDeclareModuleExports(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.DeclareModuleExports> | null,
 ): node is t.DeclareModuleExports {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "DeclareModuleExports") return false;
+  if (node.type !== "DeclareModuleExports") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isDeclareTypeAlias(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.DeclareTypeAlias> | null,
 ): node is t.DeclareTypeAlias {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "DeclareTypeAlias") return false;
+  if (node.type !== "DeclareTypeAlias") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isDeclareOpaqueType(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.DeclareOpaqueType> | null,
 ): node is t.DeclareOpaqueType {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "DeclareOpaqueType") return false;
+  if (node.type !== "DeclareOpaqueType") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isDeclareVariable(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.DeclareVariable> | null,
 ): node is t.DeclareVariable {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "DeclareVariable") return false;
+  if (node.type !== "DeclareVariable") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isDeclareExportDeclaration(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.DeclareExportDeclaration> | null,
 ): node is t.DeclareExportDeclaration {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "DeclareExportDeclaration") return false;
+  if (node.type !== "DeclareExportDeclaration") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isDeclareExportAllDeclaration(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.DeclareExportAllDeclaration> | null,
 ): node is t.DeclareExportAllDeclaration {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "DeclareExportAllDeclaration") return false;
+  if (node.type !== "DeclareExportAllDeclaration") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isDeclaredPredicate(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.DeclaredPredicate> | null,
 ): node is t.DeclaredPredicate {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "DeclaredPredicate") return false;
+  if (node.type !== "DeclaredPredicate") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isExistsTypeAnnotation(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.ExistsTypeAnnotation> | null,
 ): node is t.ExistsTypeAnnotation {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "ExistsTypeAnnotation") return false;
+  if (node.type !== "ExistsTypeAnnotation") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isFunctionTypeAnnotation(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.FunctionTypeAnnotation> | null,
 ): node is t.FunctionTypeAnnotation {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "FunctionTypeAnnotation") return false;
+  if (node.type !== "FunctionTypeAnnotation") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isFunctionTypeParam(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.FunctionTypeParam> | null,
 ): node is t.FunctionTypeParam {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "FunctionTypeParam") return false;
+  if (node.type !== "FunctionTypeParam") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isGenericTypeAnnotation(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.GenericTypeAnnotation> | null,
 ): node is t.GenericTypeAnnotation {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "GenericTypeAnnotation") return false;
+  if (node.type !== "GenericTypeAnnotation") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isInferredPredicate(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.InferredPredicate> | null,
 ): node is t.InferredPredicate {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "InferredPredicate") return false;
+  if (node.type !== "InferredPredicate") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isInterfaceExtends(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.InterfaceExtends> | null,
 ): node is t.InterfaceExtends {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "InterfaceExtends") return false;
+  if (node.type !== "InterfaceExtends") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isInterfaceDeclaration(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.InterfaceDeclaration> | null,
 ): node is t.InterfaceDeclaration {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "InterfaceDeclaration") return false;
+  if (node.type !== "InterfaceDeclaration") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isInterfaceTypeAnnotation(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.InterfaceTypeAnnotation> | null,
 ): node is t.InterfaceTypeAnnotation {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "InterfaceTypeAnnotation") return false;
+  if (node.type !== "InterfaceTypeAnnotation") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isIntersectionTypeAnnotation(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.IntersectionTypeAnnotation> | null,
 ): node is t.IntersectionTypeAnnotation {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "IntersectionTypeAnnotation") return false;
+  if (node.type !== "IntersectionTypeAnnotation") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isMixedTypeAnnotation(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.MixedTypeAnnotation> | null,
 ): node is t.MixedTypeAnnotation {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "MixedTypeAnnotation") return false;
+  if (node.type !== "MixedTypeAnnotation") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isEmptyTypeAnnotation(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.EmptyTypeAnnotation> | null,
 ): node is t.EmptyTypeAnnotation {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "EmptyTypeAnnotation") return false;
+  if (node.type !== "EmptyTypeAnnotation") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isNullableTypeAnnotation(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.NullableTypeAnnotation> | null,
 ): node is t.NullableTypeAnnotation {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "NullableTypeAnnotation") return false;
+  if (node.type !== "NullableTypeAnnotation") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isNumberLiteralTypeAnnotation(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.NumberLiteralTypeAnnotation> | null,
 ): node is t.NumberLiteralTypeAnnotation {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "NumberLiteralTypeAnnotation") return false;
+  if (node.type !== "NumberLiteralTypeAnnotation") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isNumberTypeAnnotation(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.NumberTypeAnnotation> | null,
 ): node is t.NumberTypeAnnotation {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "NumberTypeAnnotation") return false;
+  if (node.type !== "NumberTypeAnnotation") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isObjectTypeAnnotation(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.ObjectTypeAnnotation> | null,
 ): node is t.ObjectTypeAnnotation {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "ObjectTypeAnnotation") return false;
+  if (node.type !== "ObjectTypeAnnotation") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isObjectTypeInternalSlot(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.ObjectTypeInternalSlot> | null,
 ): node is t.ObjectTypeInternalSlot {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "ObjectTypeInternalSlot") return false;
+  if (node.type !== "ObjectTypeInternalSlot") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isObjectTypeCallProperty(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.ObjectTypeCallProperty> | null,
 ): node is t.ObjectTypeCallProperty {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "ObjectTypeCallProperty") return false;
+  if (node.type !== "ObjectTypeCallProperty") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isObjectTypeIndexer(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.ObjectTypeIndexer> | null,
 ): node is t.ObjectTypeIndexer {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "ObjectTypeIndexer") return false;
+  if (node.type !== "ObjectTypeIndexer") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isObjectTypeProperty(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.ObjectTypeProperty> | null,
 ): node is t.ObjectTypeProperty {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "ObjectTypeProperty") return false;
+  if (node.type !== "ObjectTypeProperty") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isObjectTypeSpreadProperty(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.ObjectTypeSpreadProperty> | null,
 ): node is t.ObjectTypeSpreadProperty {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "ObjectTypeSpreadProperty") return false;
+  if (node.type !== "ObjectTypeSpreadProperty") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isOpaqueType(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.OpaqueType> | null,
 ): node is t.OpaqueType {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "OpaqueType") return false;
+  if (node.type !== "OpaqueType") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isQualifiedTypeIdentifier(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.QualifiedTypeIdentifier> | null,
 ): node is t.QualifiedTypeIdentifier {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "QualifiedTypeIdentifier") return false;
+  if (node.type !== "QualifiedTypeIdentifier") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isStringLiteralTypeAnnotation(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.StringLiteralTypeAnnotation> | null,
 ): node is t.StringLiteralTypeAnnotation {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "StringLiteralTypeAnnotation") return false;
+  if (node.type !== "StringLiteralTypeAnnotation") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isStringTypeAnnotation(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.StringTypeAnnotation> | null,
 ): node is t.StringTypeAnnotation {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "StringTypeAnnotation") return false;
+  if (node.type !== "StringTypeAnnotation") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isSymbolTypeAnnotation(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.SymbolTypeAnnotation> | null,
 ): node is t.SymbolTypeAnnotation {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "SymbolTypeAnnotation") return false;
+  if (node.type !== "SymbolTypeAnnotation") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isThisTypeAnnotation(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.ThisTypeAnnotation> | null,
 ): node is t.ThisTypeAnnotation {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "ThisTypeAnnotation") return false;
+  if (node.type !== "ThisTypeAnnotation") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTupleTypeAnnotation(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TupleTypeAnnotation> | null,
 ): node is t.TupleTypeAnnotation {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TupleTypeAnnotation") return false;
+  if (node.type !== "TupleTypeAnnotation") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTypeofTypeAnnotation(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TypeofTypeAnnotation> | null,
 ): node is t.TypeofTypeAnnotation {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TypeofTypeAnnotation") return false;
+  if (node.type !== "TypeofTypeAnnotation") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTypeAlias(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TypeAlias> | null,
 ): node is t.TypeAlias {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TypeAlias") return false;
+  if (node.type !== "TypeAlias") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTypeAnnotation(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TypeAnnotation> | null,
 ): node is t.TypeAnnotation {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TypeAnnotation") return false;
+  if (node.type !== "TypeAnnotation") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTypeCastExpression(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TypeCastExpression> | null,
 ): node is t.TypeCastExpression {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TypeCastExpression") return false;
+  if (node.type !== "TypeCastExpression") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTypeParameter(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TypeParameter> | null,
 ): node is t.TypeParameter {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TypeParameter") return false;
+  if (node.type !== "TypeParameter") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTypeParameterDeclaration(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TypeParameterDeclaration> | null,
 ): node is t.TypeParameterDeclaration {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TypeParameterDeclaration") return false;
+  if (node.type !== "TypeParameterDeclaration") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTypeParameterInstantiation(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TypeParameterInstantiation> | null,
 ): node is t.TypeParameterInstantiation {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TypeParameterInstantiation") return false;
+  if (node.type !== "TypeParameterInstantiation") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isUnionTypeAnnotation(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.UnionTypeAnnotation> | null,
 ): node is t.UnionTypeAnnotation {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "UnionTypeAnnotation") return false;
+  if (node.type !== "UnionTypeAnnotation") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isVariance(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.Variance> | null,
 ): node is t.Variance {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "Variance") return false;
+  if (node.type !== "Variance") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isVoidTypeAnnotation(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.VoidTypeAnnotation> | null,
 ): node is t.VoidTypeAnnotation {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "VoidTypeAnnotation") return false;
+  if (node.type !== "VoidTypeAnnotation") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isEnumDeclaration(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.EnumDeclaration> | null,
 ): node is t.EnumDeclaration {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "EnumDeclaration") return false;
+  if (node.type !== "EnumDeclaration") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isEnumBooleanBody(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.EnumBooleanBody> | null,
 ): node is t.EnumBooleanBody {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "EnumBooleanBody") return false;
+  if (node.type !== "EnumBooleanBody") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isEnumNumberBody(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.EnumNumberBody> | null,
 ): node is t.EnumNumberBody {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "EnumNumberBody") return false;
+  if (node.type !== "EnumNumberBody") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isEnumStringBody(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.EnumStringBody> | null,
 ): node is t.EnumStringBody {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "EnumStringBody") return false;
+  if (node.type !== "EnumStringBody") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isEnumSymbolBody(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.EnumSymbolBody> | null,
 ): node is t.EnumSymbolBody {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "EnumSymbolBody") return false;
+  if (node.type !== "EnumSymbolBody") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isEnumBooleanMember(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.EnumBooleanMember> | null,
 ): node is t.EnumBooleanMember {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "EnumBooleanMember") return false;
+  if (node.type !== "EnumBooleanMember") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isEnumNumberMember(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.EnumNumberMember> | null,
 ): node is t.EnumNumberMember {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "EnumNumberMember") return false;
+  if (node.type !== "EnumNumberMember") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isEnumStringMember(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.EnumStringMember> | null,
 ): node is t.EnumStringMember {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "EnumStringMember") return false;
+  if (node.type !== "EnumStringMember") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isEnumDefaultedMember(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.EnumDefaultedMember> | null,
 ): node is t.EnumDefaultedMember {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "EnumDefaultedMember") return false;
+  if (node.type !== "EnumDefaultedMember") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isIndexedAccessType(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.IndexedAccessType> | null,
 ): node is t.IndexedAccessType {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "IndexedAccessType") return false;
+  if (node.type !== "IndexedAccessType") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isOptionalIndexedAccessType(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.OptionalIndexedAccessType> | null,
 ): node is t.OptionalIndexedAccessType {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "OptionalIndexedAccessType") return false;
+  if (node.type !== "OptionalIndexedAccessType") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isJSXAttribute(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.JSXAttribute> | null,
 ): node is t.JSXAttribute {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "JSXAttribute") return false;
+  if (node.type !== "JSXAttribute") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isJSXClosingElement(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.JSXClosingElement> | null,
 ): node is t.JSXClosingElement {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "JSXClosingElement") return false;
+  if (node.type !== "JSXClosingElement") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isJSXElement(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.JSXElement> | null,
 ): node is t.JSXElement {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "JSXElement") return false;
+  if (node.type !== "JSXElement") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isJSXEmptyExpression(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.JSXEmptyExpression> | null,
 ): node is t.JSXEmptyExpression {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "JSXEmptyExpression") return false;
+  if (node.type !== "JSXEmptyExpression") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isJSXExpressionContainer(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.JSXExpressionContainer> | null,
 ): node is t.JSXExpressionContainer {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "JSXExpressionContainer") return false;
+  if (node.type !== "JSXExpressionContainer") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isJSXSpreadChild(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.JSXSpreadChild> | null,
 ): node is t.JSXSpreadChild {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "JSXSpreadChild") return false;
+  if (node.type !== "JSXSpreadChild") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isJSXIdentifier(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.JSXIdentifier> | null,
 ): node is t.JSXIdentifier {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "JSXIdentifier") return false;
+  if (node.type !== "JSXIdentifier") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isJSXMemberExpression(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.JSXMemberExpression> | null,
 ): node is t.JSXMemberExpression {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "JSXMemberExpression") return false;
+  if (node.type !== "JSXMemberExpression") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isJSXNamespacedName(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.JSXNamespacedName> | null,
 ): node is t.JSXNamespacedName {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "JSXNamespacedName") return false;
+  if (node.type !== "JSXNamespacedName") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isJSXOpeningElement(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.JSXOpeningElement> | null,
 ): node is t.JSXOpeningElement {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "JSXOpeningElement") return false;
+  if (node.type !== "JSXOpeningElement") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isJSXSpreadAttribute(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.JSXSpreadAttribute> | null,
 ): node is t.JSXSpreadAttribute {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "JSXSpreadAttribute") return false;
+  if (node.type !== "JSXSpreadAttribute") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isJSXText(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.JSXText> | null,
 ): node is t.JSXText {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "JSXText") return false;
+  if (node.type !== "JSXText") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isJSXFragment(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.JSXFragment> | null,
 ): node is t.JSXFragment {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "JSXFragment") return false;
+  if (node.type !== "JSXFragment") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isJSXOpeningFragment(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.JSXOpeningFragment> | null,
 ): node is t.JSXOpeningFragment {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "JSXOpeningFragment") return false;
+  if (node.type !== "JSXOpeningFragment") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isJSXClosingFragment(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.JSXClosingFragment> | null,
 ): node is t.JSXClosingFragment {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "JSXClosingFragment") return false;
+  if (node.type !== "JSXClosingFragment") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isNoop(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.Noop> | null,
 ): node is t.Noop {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "Noop") return false;
+  if (node.type !== "Noop") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isPlaceholder(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.Placeholder> | null,
 ): node is t.Placeholder {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "Placeholder") return false;
+  if (node.type !== "Placeholder") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isV8IntrinsicIdentifier(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.V8IntrinsicIdentifier> | null,
 ): node is t.V8IntrinsicIdentifier {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "V8IntrinsicIdentifier") return false;
+  if (node.type !== "V8IntrinsicIdentifier") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isArgumentPlaceholder(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.ArgumentPlaceholder> | null,
 ): node is t.ArgumentPlaceholder {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "ArgumentPlaceholder") return false;
+  if (node.type !== "ArgumentPlaceholder") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isBindExpression(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.BindExpression> | null,
 ): node is t.BindExpression {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "BindExpression") return false;
+  if (node.type !== "BindExpression") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isImportAttribute(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.ImportAttribute> | null,
 ): node is t.ImportAttribute {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "ImportAttribute") return false;
+  if (node.type !== "ImportAttribute") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isDecorator(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.Decorator> | null,
 ): node is t.Decorator {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "Decorator") return false;
+  if (node.type !== "Decorator") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isDoExpression(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.DoExpression> | null,
 ): node is t.DoExpression {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "DoExpression") return false;
+  if (node.type !== "DoExpression") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isExportDefaultSpecifier(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.ExportDefaultSpecifier> | null,
 ): node is t.ExportDefaultSpecifier {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "ExportDefaultSpecifier") return false;
+  if (node.type !== "ExportDefaultSpecifier") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isRecordExpression(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.RecordExpression> | null,
 ): node is t.RecordExpression {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "RecordExpression") return false;
+  if (node.type !== "RecordExpression") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTupleExpression(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TupleExpression> | null,
 ): node is t.TupleExpression {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TupleExpression") return false;
+  if (node.type !== "TupleExpression") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isDecimalLiteral(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.DecimalLiteral> | null,
 ): node is t.DecimalLiteral {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "DecimalLiteral") return false;
+  if (node.type !== "DecimalLiteral") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isModuleExpression(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.ModuleExpression> | null,
 ): node is t.ModuleExpression {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "ModuleExpression") return false;
+  if (node.type !== "ModuleExpression") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTopicReference(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TopicReference> | null,
 ): node is t.TopicReference {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TopicReference") return false;
+  if (node.type !== "TopicReference") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isPipelineTopicExpression(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.PipelineTopicExpression> | null,
 ): node is t.PipelineTopicExpression {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "PipelineTopicExpression") return false;
+  if (node.type !== "PipelineTopicExpression") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isPipelineBareFunction(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.PipelineBareFunction> | null,
 ): node is t.PipelineBareFunction {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "PipelineBareFunction") return false;
+  if (node.type !== "PipelineBareFunction") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isPipelinePrimaryTopicReference(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.PipelinePrimaryTopicReference> | null,
 ): node is t.PipelinePrimaryTopicReference {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "PipelinePrimaryTopicReference") return false;
+  if (node.type !== "PipelinePrimaryTopicReference") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTSParameterProperty(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TSParameterProperty> | null,
 ): node is t.TSParameterProperty {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TSParameterProperty") return false;
+  if (node.type !== "TSParameterProperty") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTSDeclareFunction(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TSDeclareFunction> | null,
 ): node is t.TSDeclareFunction {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TSDeclareFunction") return false;
+  if (node.type !== "TSDeclareFunction") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTSDeclareMethod(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TSDeclareMethod> | null,
 ): node is t.TSDeclareMethod {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TSDeclareMethod") return false;
+  if (node.type !== "TSDeclareMethod") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTSQualifiedName(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TSQualifiedName> | null,
 ): node is t.TSQualifiedName {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TSQualifiedName") return false;
+  if (node.type !== "TSQualifiedName") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTSCallSignatureDeclaration(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TSCallSignatureDeclaration> | null,
 ): node is t.TSCallSignatureDeclaration {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TSCallSignatureDeclaration") return false;
+  if (node.type !== "TSCallSignatureDeclaration") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTSConstructSignatureDeclaration(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TSConstructSignatureDeclaration> | null,
 ): node is t.TSConstructSignatureDeclaration {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TSConstructSignatureDeclaration") return false;
+  if (node.type !== "TSConstructSignatureDeclaration") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTSPropertySignature(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TSPropertySignature> | null,
 ): node is t.TSPropertySignature {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TSPropertySignature") return false;
+  if (node.type !== "TSPropertySignature") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTSMethodSignature(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TSMethodSignature> | null,
 ): node is t.TSMethodSignature {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TSMethodSignature") return false;
+  if (node.type !== "TSMethodSignature") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTSIndexSignature(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TSIndexSignature> | null,
 ): node is t.TSIndexSignature {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TSIndexSignature") return false;
+  if (node.type !== "TSIndexSignature") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTSAnyKeyword(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TSAnyKeyword> | null,
 ): node is t.TSAnyKeyword {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TSAnyKeyword") return false;
+  if (node.type !== "TSAnyKeyword") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTSBooleanKeyword(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TSBooleanKeyword> | null,
 ): node is t.TSBooleanKeyword {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TSBooleanKeyword") return false;
+  if (node.type !== "TSBooleanKeyword") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTSBigIntKeyword(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TSBigIntKeyword> | null,
 ): node is t.TSBigIntKeyword {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TSBigIntKeyword") return false;
+  if (node.type !== "TSBigIntKeyword") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTSIntrinsicKeyword(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TSIntrinsicKeyword> | null,
 ): node is t.TSIntrinsicKeyword {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TSIntrinsicKeyword") return false;
+  if (node.type !== "TSIntrinsicKeyword") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTSNeverKeyword(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TSNeverKeyword> | null,
 ): node is t.TSNeverKeyword {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TSNeverKeyword") return false;
+  if (node.type !== "TSNeverKeyword") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTSNullKeyword(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TSNullKeyword> | null,
 ): node is t.TSNullKeyword {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TSNullKeyword") return false;
+  if (node.type !== "TSNullKeyword") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTSNumberKeyword(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TSNumberKeyword> | null,
 ): node is t.TSNumberKeyword {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TSNumberKeyword") return false;
+  if (node.type !== "TSNumberKeyword") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTSObjectKeyword(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TSObjectKeyword> | null,
 ): node is t.TSObjectKeyword {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TSObjectKeyword") return false;
+  if (node.type !== "TSObjectKeyword") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTSStringKeyword(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TSStringKeyword> | null,
 ): node is t.TSStringKeyword {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TSStringKeyword") return false;
+  if (node.type !== "TSStringKeyword") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTSSymbolKeyword(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TSSymbolKeyword> | null,
 ): node is t.TSSymbolKeyword {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TSSymbolKeyword") return false;
+  if (node.type !== "TSSymbolKeyword") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTSUndefinedKeyword(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TSUndefinedKeyword> | null,
 ): node is t.TSUndefinedKeyword {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TSUndefinedKeyword") return false;
+  if (node.type !== "TSUndefinedKeyword") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTSUnknownKeyword(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TSUnknownKeyword> | null,
 ): node is t.TSUnknownKeyword {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TSUnknownKeyword") return false;
+  if (node.type !== "TSUnknownKeyword") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTSVoidKeyword(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TSVoidKeyword> | null,
 ): node is t.TSVoidKeyword {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TSVoidKeyword") return false;
+  if (node.type !== "TSVoidKeyword") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTSThisType(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TSThisType> | null,
 ): node is t.TSThisType {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TSThisType") return false;
+  if (node.type !== "TSThisType") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTSFunctionType(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TSFunctionType> | null,
 ): node is t.TSFunctionType {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TSFunctionType") return false;
+  if (node.type !== "TSFunctionType") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTSConstructorType(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TSConstructorType> | null,
 ): node is t.TSConstructorType {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TSConstructorType") return false;
+  if (node.type !== "TSConstructorType") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTSTypeReference(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TSTypeReference> | null,
 ): node is t.TSTypeReference {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TSTypeReference") return false;
+  if (node.type !== "TSTypeReference") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTSTypePredicate(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TSTypePredicate> | null,
 ): node is t.TSTypePredicate {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TSTypePredicate") return false;
+  if (node.type !== "TSTypePredicate") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTSTypeQuery(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TSTypeQuery> | null,
 ): node is t.TSTypeQuery {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TSTypeQuery") return false;
+  if (node.type !== "TSTypeQuery") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTSTypeLiteral(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TSTypeLiteral> | null,
 ): node is t.TSTypeLiteral {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TSTypeLiteral") return false;
+  if (node.type !== "TSTypeLiteral") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTSArrayType(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TSArrayType> | null,
 ): node is t.TSArrayType {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TSArrayType") return false;
+  if (node.type !== "TSArrayType") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTSTupleType(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TSTupleType> | null,
 ): node is t.TSTupleType {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TSTupleType") return false;
+  if (node.type !== "TSTupleType") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTSOptionalType(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TSOptionalType> | null,
 ): node is t.TSOptionalType {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TSOptionalType") return false;
+  if (node.type !== "TSOptionalType") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTSRestType(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TSRestType> | null,
 ): node is t.TSRestType {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TSRestType") return false;
+  if (node.type !== "TSRestType") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTSNamedTupleMember(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TSNamedTupleMember> | null,
 ): node is t.TSNamedTupleMember {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TSNamedTupleMember") return false;
+  if (node.type !== "TSNamedTupleMember") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTSUnionType(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TSUnionType> | null,
 ): node is t.TSUnionType {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TSUnionType") return false;
+  if (node.type !== "TSUnionType") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTSIntersectionType(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TSIntersectionType> | null,
 ): node is t.TSIntersectionType {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TSIntersectionType") return false;
+  if (node.type !== "TSIntersectionType") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTSConditionalType(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TSConditionalType> | null,
 ): node is t.TSConditionalType {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TSConditionalType") return false;
+  if (node.type !== "TSConditionalType") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTSInferType(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TSInferType> | null,
 ): node is t.TSInferType {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TSInferType") return false;
+  if (node.type !== "TSInferType") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTSParenthesizedType(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TSParenthesizedType> | null,
 ): node is t.TSParenthesizedType {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TSParenthesizedType") return false;
+  if (node.type !== "TSParenthesizedType") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTSTypeOperator(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TSTypeOperator> | null,
 ): node is t.TSTypeOperator {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TSTypeOperator") return false;
+  if (node.type !== "TSTypeOperator") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTSIndexedAccessType(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TSIndexedAccessType> | null,
 ): node is t.TSIndexedAccessType {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TSIndexedAccessType") return false;
+  if (node.type !== "TSIndexedAccessType") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTSMappedType(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TSMappedType> | null,
 ): node is t.TSMappedType {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TSMappedType") return false;
+  if (node.type !== "TSMappedType") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTSLiteralType(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TSLiteralType> | null,
 ): node is t.TSLiteralType {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TSLiteralType") return false;
+  if (node.type !== "TSLiteralType") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTSExpressionWithTypeArguments(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TSExpressionWithTypeArguments> | null,
 ): node is t.TSExpressionWithTypeArguments {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TSExpressionWithTypeArguments") return false;
+  if (node.type !== "TSExpressionWithTypeArguments") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTSInterfaceDeclaration(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TSInterfaceDeclaration> | null,
 ): node is t.TSInterfaceDeclaration {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TSInterfaceDeclaration") return false;
+  if (node.type !== "TSInterfaceDeclaration") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTSInterfaceBody(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TSInterfaceBody> | null,
 ): node is t.TSInterfaceBody {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TSInterfaceBody") return false;
+  if (node.type !== "TSInterfaceBody") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTSTypeAliasDeclaration(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TSTypeAliasDeclaration> | null,
 ): node is t.TSTypeAliasDeclaration {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TSTypeAliasDeclaration") return false;
+  if (node.type !== "TSTypeAliasDeclaration") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTSInstantiationExpression(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TSInstantiationExpression> | null,
 ): node is t.TSInstantiationExpression {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TSInstantiationExpression") return false;
+  if (node.type !== "TSInstantiationExpression") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTSAsExpression(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TSAsExpression> | null,
 ): node is t.TSAsExpression {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TSAsExpression") return false;
+  if (node.type !== "TSAsExpression") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTSSatisfiesExpression(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TSSatisfiesExpression> | null,
 ): node is t.TSSatisfiesExpression {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TSSatisfiesExpression") return false;
+  if (node.type !== "TSSatisfiesExpression") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTSTypeAssertion(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TSTypeAssertion> | null,
 ): node is t.TSTypeAssertion {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TSTypeAssertion") return false;
+  if (node.type !== "TSTypeAssertion") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTSEnumDeclaration(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TSEnumDeclaration> | null,
 ): node is t.TSEnumDeclaration {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TSEnumDeclaration") return false;
+  if (node.type !== "TSEnumDeclaration") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTSEnumMember(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TSEnumMember> | null,
 ): node is t.TSEnumMember {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TSEnumMember") return false;
+  if (node.type !== "TSEnumMember") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTSModuleDeclaration(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TSModuleDeclaration> | null,
 ): node is t.TSModuleDeclaration {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TSModuleDeclaration") return false;
+  if (node.type !== "TSModuleDeclaration") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTSModuleBlock(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TSModuleBlock> | null,
 ): node is t.TSModuleBlock {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TSModuleBlock") return false;
+  if (node.type !== "TSModuleBlock") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTSImportType(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TSImportType> | null,
 ): node is t.TSImportType {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TSImportType") return false;
+  if (node.type !== "TSImportType") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTSImportEqualsDeclaration(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TSImportEqualsDeclaration> | null,
 ): node is t.TSImportEqualsDeclaration {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TSImportEqualsDeclaration") return false;
+  if (node.type !== "TSImportEqualsDeclaration") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTSExternalModuleReference(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TSExternalModuleReference> | null,
 ): node is t.TSExternalModuleReference {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TSExternalModuleReference") return false;
+  if (node.type !== "TSExternalModuleReference") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTSNonNullExpression(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TSNonNullExpression> | null,
 ): node is t.TSNonNullExpression {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TSNonNullExpression") return false;
+  if (node.type !== "TSNonNullExpression") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTSExportAssignment(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TSExportAssignment> | null,
 ): node is t.TSExportAssignment {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TSExportAssignment") return false;
+  if (node.type !== "TSExportAssignment") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTSNamespaceExportDeclaration(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TSNamespaceExportDeclaration> | null,
 ): node is t.TSNamespaceExportDeclaration {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TSNamespaceExportDeclaration") return false;
+  if (node.type !== "TSNamespaceExportDeclaration") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTSTypeAnnotation(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TSTypeAnnotation> | null,
 ): node is t.TSTypeAnnotation {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TSTypeAnnotation") return false;
+  if (node.type !== "TSTypeAnnotation") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTSTypeParameterInstantiation(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TSTypeParameterInstantiation> | null,
 ): node is t.TSTypeParameterInstantiation {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TSTypeParameterInstantiation") return false;
+  if (node.type !== "TSTypeParameterInstantiation") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTSTypeParameterDeclaration(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TSTypeParameterDeclaration> | null,
 ): node is t.TSTypeParameterDeclaration {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TSTypeParameterDeclaration") return false;
+  if (node.type !== "TSTypeParameterDeclaration") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isTSTypeParameter(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TSTypeParameter> | null,
 ): node is t.TSTypeParameter {
   if (!node) return false;
 
-  if ((node as t.Node).type !== "TSTypeParameter") return false;
+  if (node.type !== "TSTypeParameter") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
 export function isStandardized(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.Standardized> | null,
 ): node is t.Standardized {
   if (!node) return false;
 
-  switch ((node as t.Node).type) {
+  switch (node.type) {
     case "ArrayExpression":
     case "AssignmentExpression":
     case "BinaryExpression":
@@ -2592,7 +2600,7 @@ export function isStandardized(
     case "StaticBlock":
       break;
     case "Placeholder":
-      switch ((node as t.Placeholder).expectedNode) {
+      switch (node.expectedNode) {
         case "Identifier":
         case "StringLiteral":
         case "BlockStatement":
@@ -2609,12 +2617,12 @@ export function isStandardized(
   return opts == null || shallowEqual(node, opts);
 }
 export function isExpression(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.Expression> | null,
 ): node is t.Expression {
   if (!node) return false;
 
-  switch ((node as t.Node).type) {
+  switch (node.type) {
     case "ArrayExpression":
     case "AssignmentExpression":
     case "BinaryExpression":
@@ -2668,7 +2676,7 @@ export function isExpression(
     case "TSNonNullExpression":
       break;
     case "Placeholder":
-      switch ((node as t.Placeholder).expectedNode) {
+      switch (node.expectedNode) {
         case "Expression":
         case "Identifier":
         case "StringLiteral":
@@ -2684,12 +2692,12 @@ export function isExpression(
   return opts == null || shallowEqual(node, opts);
 }
 export function isBinary(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.Binary> | null,
 ): node is t.Binary {
   if (!node) return false;
 
-  switch ((node as t.Node).type) {
+  switch (node.type) {
     case "BinaryExpression":
     case "LogicalExpression":
       break;
@@ -2700,12 +2708,12 @@ export function isBinary(
   return opts == null || shallowEqual(node, opts);
 }
 export function isScopable(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.Scopable> | null,
 ): node is t.Scopable {
   if (!node) return false;
 
-  switch ((node as t.Node).type) {
+  switch (node.type) {
     case "BlockStatement":
     case "CatchClause":
     case "DoWhileStatement":
@@ -2727,7 +2735,7 @@ export function isScopable(
     case "TSModuleBlock":
       break;
     case "Placeholder":
-      switch ((node as t.Placeholder).expectedNode) {
+      switch (node.expectedNode) {
         case "BlockStatement":
           break;
         default:
@@ -2741,12 +2749,12 @@ export function isScopable(
   return opts == null || shallowEqual(node, opts);
 }
 export function isBlockParent(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.BlockParent> | null,
 ): node is t.BlockParent {
   if (!node) return false;
 
-  switch ((node as t.Node).type) {
+  switch (node.type) {
     case "BlockStatement":
     case "CatchClause":
     case "DoWhileStatement":
@@ -2766,7 +2774,7 @@ export function isBlockParent(
     case "TSModuleBlock":
       break;
     case "Placeholder":
-      switch ((node as t.Placeholder).expectedNode) {
+      switch (node.expectedNode) {
         case "BlockStatement":
           break;
         default:
@@ -2780,18 +2788,18 @@ export function isBlockParent(
   return opts == null || shallowEqual(node, opts);
 }
 export function isBlock(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.Block> | null,
 ): node is t.Block {
   if (!node) return false;
 
-  switch ((node as t.Node).type) {
+  switch (node.type) {
     case "BlockStatement":
     case "Program":
     case "TSModuleBlock":
       break;
     case "Placeholder":
-      switch ((node as t.Placeholder).expectedNode) {
+      switch (node.expectedNode) {
         case "BlockStatement":
           break;
         default:
@@ -2805,12 +2813,12 @@ export function isBlock(
   return opts == null || shallowEqual(node, opts);
 }
 export function isStatement(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.Statement> | null,
 ): node is t.Statement {
   if (!node) return false;
 
-  switch ((node as t.Node).type) {
+  switch (node.type) {
     case "BlockStatement":
     case "BreakStatement":
     case "ContinueStatement":
@@ -2860,7 +2868,7 @@ export function isStatement(
     case "TSNamespaceExportDeclaration":
       break;
     case "Placeholder":
-      switch ((node as t.Placeholder).expectedNode) {
+      switch (node.expectedNode) {
         case "Statement":
         case "Declaration":
         case "BlockStatement":
@@ -2876,12 +2884,12 @@ export function isStatement(
   return opts == null || shallowEqual(node, opts);
 }
 export function isTerminatorless(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.Terminatorless> | null,
 ): node is t.Terminatorless {
   if (!node) return false;
 
-  switch ((node as t.Node).type) {
+  switch (node.type) {
     case "BreakStatement":
     case "ContinueStatement":
     case "ReturnStatement":
@@ -2896,12 +2904,12 @@ export function isTerminatorless(
   return opts == null || shallowEqual(node, opts);
 }
 export function isCompletionStatement(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.CompletionStatement> | null,
 ): node is t.CompletionStatement {
   if (!node) return false;
 
-  switch ((node as t.Node).type) {
+  switch (node.type) {
     case "BreakStatement":
     case "ContinueStatement":
     case "ReturnStatement":
@@ -2914,12 +2922,12 @@ export function isCompletionStatement(
   return opts == null || shallowEqual(node, opts);
 }
 export function isConditional(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.Conditional> | null,
 ): node is t.Conditional {
   if (!node) return false;
 
-  switch ((node as t.Node).type) {
+  switch (node.type) {
     case "ConditionalExpression":
     case "IfStatement":
       break;
@@ -2930,12 +2938,12 @@ export function isConditional(
   return opts == null || shallowEqual(node, opts);
 }
 export function isLoop(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.Loop> | null,
 ): node is t.Loop {
   if (!node) return false;
 
-  switch ((node as t.Node).type) {
+  switch (node.type) {
     case "DoWhileStatement":
     case "ForInStatement":
     case "ForStatement":
@@ -2949,12 +2957,12 @@ export function isLoop(
   return opts == null || shallowEqual(node, opts);
 }
 export function isWhile(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.While> | null,
 ): node is t.While {
   if (!node) return false;
 
-  switch ((node as t.Node).type) {
+  switch (node.type) {
     case "DoWhileStatement":
     case "WhileStatement":
       break;
@@ -2965,12 +2973,12 @@ export function isWhile(
   return opts == null || shallowEqual(node, opts);
 }
 export function isExpressionWrapper(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.ExpressionWrapper> | null,
 ): node is t.ExpressionWrapper {
   if (!node) return false;
 
-  switch ((node as t.Node).type) {
+  switch (node.type) {
     case "ExpressionStatement":
     case "ParenthesizedExpression":
     case "TypeCastExpression":
@@ -2982,12 +2990,12 @@ export function isExpressionWrapper(
   return opts == null || shallowEqual(node, opts);
 }
 export function isFor(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.For> | null,
 ): node is t.For {
   if (!node) return false;
 
-  switch ((node as t.Node).type) {
+  switch (node.type) {
     case "ForInStatement":
     case "ForStatement":
     case "ForOfStatement":
@@ -2999,12 +3007,12 @@ export function isFor(
   return opts == null || shallowEqual(node, opts);
 }
 export function isForXStatement(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.ForXStatement> | null,
 ): node is t.ForXStatement {
   if (!node) return false;
 
-  switch ((node as t.Node).type) {
+  switch (node.type) {
     case "ForInStatement":
     case "ForOfStatement":
       break;
@@ -3015,12 +3023,12 @@ export function isForXStatement(
   return opts == null || shallowEqual(node, opts);
 }
 export function isFunction(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.Function> | null,
 ): node is t.Function {
   if (!node) return false;
 
-  switch ((node as t.Node).type) {
+  switch (node.type) {
     case "FunctionDeclaration":
     case "FunctionExpression":
     case "ObjectMethod":
@@ -3035,12 +3043,12 @@ export function isFunction(
   return opts == null || shallowEqual(node, opts);
 }
 export function isFunctionParent(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.FunctionParent> | null,
 ): node is t.FunctionParent {
   if (!node) return false;
 
-  switch ((node as t.Node).type) {
+  switch (node.type) {
     case "FunctionDeclaration":
     case "FunctionExpression":
     case "ObjectMethod":
@@ -3057,12 +3065,12 @@ export function isFunctionParent(
   return opts == null || shallowEqual(node, opts);
 }
 export function isPureish(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.Pureish> | null,
 ): node is t.Pureish {
   if (!node) return false;
 
-  switch ((node as t.Node).type) {
+  switch (node.type) {
     case "FunctionDeclaration":
     case "FunctionExpression":
     case "StringLiteral":
@@ -3075,7 +3083,7 @@ export function isPureish(
     case "DecimalLiteral":
       break;
     case "Placeholder":
-      switch ((node as t.Placeholder).expectedNode) {
+      switch (node.expectedNode) {
         case "StringLiteral":
           break;
         default:
@@ -3089,12 +3097,12 @@ export function isPureish(
   return opts == null || shallowEqual(node, opts);
 }
 export function isDeclaration(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.Declaration> | null,
 ): node is t.Declaration {
   if (!node) return false;
 
-  switch ((node as t.Node).type) {
+  switch (node.type) {
     case "FunctionDeclaration":
     case "VariableDeclaration":
     case "ClassDeclaration":
@@ -3123,7 +3131,7 @@ export function isDeclaration(
     case "TSModuleDeclaration":
       break;
     case "Placeholder":
-      switch ((node as t.Placeholder).expectedNode) {
+      switch (node.expectedNode) {
         case "Declaration":
           break;
         default:
@@ -3137,12 +3145,12 @@ export function isDeclaration(
   return opts == null || shallowEqual(node, opts);
 }
 export function isPatternLike(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.PatternLike> | null,
 ): node is t.PatternLike {
   if (!node) return false;
 
-  switch ((node as t.Node).type) {
+  switch (node.type) {
     case "Identifier":
     case "RestElement":
     case "AssignmentPattern":
@@ -3154,7 +3162,7 @@ export function isPatternLike(
     case "TSNonNullExpression":
       break;
     case "Placeholder":
-      switch ((node as t.Placeholder).expectedNode) {
+      switch (node.expectedNode) {
         case "Pattern":
         case "Identifier":
           break;
@@ -3169,12 +3177,12 @@ export function isPatternLike(
   return opts == null || shallowEqual(node, opts);
 }
 export function isLVal(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.LVal> | null,
 ): node is t.LVal {
   if (!node) return false;
 
-  switch ((node as t.Node).type) {
+  switch (node.type) {
     case "Identifier":
     case "MemberExpression":
     case "RestElement":
@@ -3188,7 +3196,7 @@ export function isLVal(
     case "TSNonNullExpression":
       break;
     case "Placeholder":
-      switch ((node as t.Placeholder).expectedNode) {
+      switch (node.expectedNode) {
         case "Pattern":
         case "Identifier":
           break;
@@ -3203,17 +3211,17 @@ export function isLVal(
   return opts == null || shallowEqual(node, opts);
 }
 export function isTSEntityName(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TSEntityName> | null,
 ): node is t.TSEntityName {
   if (!node) return false;
 
-  switch ((node as t.Node).type) {
+  switch (node.type) {
     case "Identifier":
     case "TSQualifiedName":
       break;
     case "Placeholder":
-      switch ((node as t.Placeholder).expectedNode) {
+      switch (node.expectedNode) {
         case "Identifier":
           break;
         default:
@@ -3227,12 +3235,12 @@ export function isTSEntityName(
   return opts == null || shallowEqual(node, opts);
 }
 export function isLiteral(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.Literal> | null,
 ): node is t.Literal {
   if (!node) return false;
 
-  switch ((node as t.Node).type) {
+  switch (node.type) {
     case "StringLiteral":
     case "NumericLiteral":
     case "NullLiteral":
@@ -3243,7 +3251,7 @@ export function isLiteral(
     case "DecimalLiteral":
       break;
     case "Placeholder":
-      switch ((node as t.Placeholder).expectedNode) {
+      switch (node.expectedNode) {
         case "StringLiteral":
           break;
         default:
@@ -3257,12 +3265,12 @@ export function isLiteral(
   return opts == null || shallowEqual(node, opts);
 }
 export function isImmutable(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.Immutable> | null,
 ): node is t.Immutable {
   if (!node) return false;
 
-  switch ((node as t.Node).type) {
+  switch (node.type) {
     case "StringLiteral":
     case "NumericLiteral":
     case "NullLiteral":
@@ -3281,7 +3289,7 @@ export function isImmutable(
     case "DecimalLiteral":
       break;
     case "Placeholder":
-      switch ((node as t.Placeholder).expectedNode) {
+      switch (node.expectedNode) {
         case "StringLiteral":
           break;
         default:
@@ -3295,12 +3303,12 @@ export function isImmutable(
   return opts == null || shallowEqual(node, opts);
 }
 export function isUserWhitespacable(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.UserWhitespacable> | null,
 ): node is t.UserWhitespacable {
   if (!node) return false;
 
-  switch ((node as t.Node).type) {
+  switch (node.type) {
     case "ObjectMethod":
     case "ObjectProperty":
     case "ObjectTypeInternalSlot":
@@ -3316,12 +3324,12 @@ export function isUserWhitespacable(
   return opts == null || shallowEqual(node, opts);
 }
 export function isMethod(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.Method> | null,
 ): node is t.Method {
   if (!node) return false;
 
-  switch ((node as t.Node).type) {
+  switch (node.type) {
     case "ObjectMethod":
     case "ClassMethod":
     case "ClassPrivateMethod":
@@ -3333,12 +3341,12 @@ export function isMethod(
   return opts == null || shallowEqual(node, opts);
 }
 export function isObjectMember(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.ObjectMember> | null,
 ): node is t.ObjectMember {
   if (!node) return false;
 
-  switch ((node as t.Node).type) {
+  switch (node.type) {
     case "ObjectMethod":
     case "ObjectProperty":
       break;
@@ -3349,12 +3357,12 @@ export function isObjectMember(
   return opts == null || shallowEqual(node, opts);
 }
 export function isProperty(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.Property> | null,
 ): node is t.Property {
   if (!node) return false;
 
-  switch ((node as t.Node).type) {
+  switch (node.type) {
     case "ObjectProperty":
     case "ClassProperty":
     case "ClassAccessorProperty":
@@ -3367,12 +3375,12 @@ export function isProperty(
   return opts == null || shallowEqual(node, opts);
 }
 export function isUnaryLike(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.UnaryLike> | null,
 ): node is t.UnaryLike {
   if (!node) return false;
 
-  switch ((node as t.Node).type) {
+  switch (node.type) {
     case "UnaryExpression":
     case "SpreadElement":
       break;
@@ -3383,18 +3391,18 @@ export function isUnaryLike(
   return opts == null || shallowEqual(node, opts);
 }
 export function isPattern(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.Pattern> | null,
 ): node is t.Pattern {
   if (!node) return false;
 
-  switch ((node as t.Node).type) {
+  switch (node.type) {
     case "AssignmentPattern":
     case "ArrayPattern":
     case "ObjectPattern":
       break;
     case "Placeholder":
-      switch ((node as t.Placeholder).expectedNode) {
+      switch (node.expectedNode) {
         case "Pattern":
           break;
         default:
@@ -3408,12 +3416,12 @@ export function isPattern(
   return opts == null || shallowEqual(node, opts);
 }
 export function isClass(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.Class> | null,
 ): node is t.Class {
   if (!node) return false;
 
-  switch ((node as t.Node).type) {
+  switch (node.type) {
     case "ClassExpression":
     case "ClassDeclaration":
       break;
@@ -3424,12 +3432,12 @@ export function isClass(
   return opts == null || shallowEqual(node, opts);
 }
 export function isImportOrExportDeclaration(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.ImportOrExportDeclaration> | null,
 ): node is t.ImportOrExportDeclaration {
   if (!node) return false;
 
-  switch ((node as t.Node).type) {
+  switch (node.type) {
     case "ExportAllDeclaration":
     case "ExportDefaultDeclaration":
     case "ExportNamedDeclaration":
@@ -3442,12 +3450,12 @@ export function isImportOrExportDeclaration(
   return opts == null || shallowEqual(node, opts);
 }
 export function isExportDeclaration(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.ExportDeclaration> | null,
 ): node is t.ExportDeclaration {
   if (!node) return false;
 
-  switch ((node as t.Node).type) {
+  switch (node.type) {
     case "ExportAllDeclaration":
     case "ExportDefaultDeclaration":
     case "ExportNamedDeclaration":
@@ -3459,12 +3467,12 @@ export function isExportDeclaration(
   return opts == null || shallowEqual(node, opts);
 }
 export function isModuleSpecifier(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.ModuleSpecifier> | null,
 ): node is t.ModuleSpecifier {
   if (!node) return false;
 
-  switch ((node as t.Node).type) {
+  switch (node.type) {
     case "ExportSpecifier":
     case "ImportDefaultSpecifier":
     case "ImportNamespaceSpecifier":
@@ -3479,12 +3487,12 @@ export function isModuleSpecifier(
   return opts == null || shallowEqual(node, opts);
 }
 export function isAccessor(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.Accessor> | null,
 ): node is t.Accessor {
   if (!node) return false;
 
-  switch ((node as t.Node).type) {
+  switch (node.type) {
     case "ClassAccessorProperty":
       break;
     default:
@@ -3494,12 +3502,12 @@ export function isAccessor(
   return opts == null || shallowEqual(node, opts);
 }
 export function isPrivate(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.Private> | null,
 ): node is t.Private {
   if (!node) return false;
 
-  switch ((node as t.Node).type) {
+  switch (node.type) {
     case "ClassPrivateProperty":
     case "ClassPrivateMethod":
     case "PrivateName":
@@ -3511,12 +3519,12 @@ export function isPrivate(
   return opts == null || shallowEqual(node, opts);
 }
 export function isFlow(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.Flow> | null,
 ): node is t.Flow {
   if (!node) return false;
 
-  switch ((node as t.Node).type) {
+  switch (node.type) {
     case "AnyTypeAnnotation":
     case "ArrayTypeAnnotation":
     case "BooleanTypeAnnotation":
@@ -3590,12 +3598,12 @@ export function isFlow(
   return opts == null || shallowEqual(node, opts);
 }
 export function isFlowType(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.FlowType> | null,
 ): node is t.FlowType {
   if (!node) return false;
 
-  switch ((node as t.Node).type) {
+  switch (node.type) {
     case "AnyTypeAnnotation":
     case "ArrayTypeAnnotation":
     case "BooleanTypeAnnotation":
@@ -3630,12 +3638,12 @@ export function isFlowType(
   return opts == null || shallowEqual(node, opts);
 }
 export function isFlowBaseAnnotation(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.FlowBaseAnnotation> | null,
 ): node is t.FlowBaseAnnotation {
   if (!node) return false;
 
-  switch ((node as t.Node).type) {
+  switch (node.type) {
     case "AnyTypeAnnotation":
     case "BooleanTypeAnnotation":
     case "NullLiteralTypeAnnotation":
@@ -3654,12 +3662,12 @@ export function isFlowBaseAnnotation(
   return opts == null || shallowEqual(node, opts);
 }
 export function isFlowDeclaration(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.FlowDeclaration> | null,
 ): node is t.FlowDeclaration {
   if (!node) return false;
 
-  switch ((node as t.Node).type) {
+  switch (node.type) {
     case "DeclareClass":
     case "DeclareFunction":
     case "DeclareInterface":
@@ -3681,12 +3689,12 @@ export function isFlowDeclaration(
   return opts == null || shallowEqual(node, opts);
 }
 export function isFlowPredicate(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.FlowPredicate> | null,
 ): node is t.FlowPredicate {
   if (!node) return false;
 
-  switch ((node as t.Node).type) {
+  switch (node.type) {
     case "DeclaredPredicate":
     case "InferredPredicate":
       break;
@@ -3697,12 +3705,12 @@ export function isFlowPredicate(
   return opts == null || shallowEqual(node, opts);
 }
 export function isEnumBody(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.EnumBody> | null,
 ): node is t.EnumBody {
   if (!node) return false;
 
-  switch ((node as t.Node).type) {
+  switch (node.type) {
     case "EnumBooleanBody":
     case "EnumNumberBody":
     case "EnumStringBody":
@@ -3715,12 +3723,12 @@ export function isEnumBody(
   return opts == null || shallowEqual(node, opts);
 }
 export function isEnumMember(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.EnumMember> | null,
 ): node is t.EnumMember {
   if (!node) return false;
 
-  switch ((node as t.Node).type) {
+  switch (node.type) {
     case "EnumBooleanMember":
     case "EnumNumberMember":
     case "EnumStringMember":
@@ -3733,12 +3741,12 @@ export function isEnumMember(
   return opts == null || shallowEqual(node, opts);
 }
 export function isJSX(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.JSX> | null,
 ): node is t.JSX {
   if (!node) return false;
 
-  switch ((node as t.Node).type) {
+  switch (node.type) {
     case "JSXAttribute":
     case "JSXClosingElement":
     case "JSXElement":
@@ -3762,12 +3770,12 @@ export function isJSX(
   return opts == null || shallowEqual(node, opts);
 }
 export function isMiscellaneous(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.Miscellaneous> | null,
 ): node is t.Miscellaneous {
   if (!node) return false;
 
-  switch ((node as t.Node).type) {
+  switch (node.type) {
     case "Noop":
     case "Placeholder":
     case "V8IntrinsicIdentifier":
@@ -3779,12 +3787,12 @@ export function isMiscellaneous(
   return opts == null || shallowEqual(node, opts);
 }
 export function isTypeScript(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TypeScript> | null,
 ): node is t.TypeScript {
   if (!node) return false;
 
-  switch ((node as t.Node).type) {
+  switch (node.type) {
     case "TSParameterProperty":
     case "TSDeclareFunction":
     case "TSDeclareMethod":
@@ -3858,12 +3866,12 @@ export function isTypeScript(
   return opts == null || shallowEqual(node, opts);
 }
 export function isTSTypeElement(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TSTypeElement> | null,
 ): node is t.TSTypeElement {
   if (!node) return false;
 
-  switch ((node as t.Node).type) {
+  switch (node.type) {
     case "TSCallSignatureDeclaration":
     case "TSConstructSignatureDeclaration":
     case "TSPropertySignature":
@@ -3877,12 +3885,12 @@ export function isTSTypeElement(
   return opts == null || shallowEqual(node, opts);
 }
 export function isTSType(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TSType> | null,
 ): node is t.TSType {
   if (!node) return false;
 
-  switch ((node as t.Node).type) {
+  switch (node.type) {
     case "TSAnyKeyword":
     case "TSBooleanKeyword":
     case "TSBigIntKeyword":
@@ -3926,12 +3934,12 @@ export function isTSType(
   return opts == null || shallowEqual(node, opts);
 }
 export function isTSBaseType(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.TSBaseType> | null,
 ): node is t.TSBaseType {
   if (!node) return false;
 
-  switch ((node as t.Node).type) {
+  switch (node.type) {
     case "TSAnyKeyword":
     case "TSBooleanKeyword":
     case "TSBigIntKeyword":
@@ -3958,13 +3966,13 @@ export function isTSBaseType(
  * @deprecated Use `isNumericLiteral`
  */
 export function isNumberLiteral(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.NumberLiteral> | null,
 ): boolean {
   deprecationWarning("isNumberLiteral", "isNumericLiteral");
   if (!node) return false;
 
-  if ((node as t.Node).type !== "NumberLiteral") return false;
+  if (node.type !== "NumberLiteral") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
@@ -3972,13 +3980,13 @@ export function isNumberLiteral(
  * @deprecated Use `isRegExpLiteral`
  */
 export function isRegexLiteral(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.RegexLiteral> | null,
 ): boolean {
   deprecationWarning("isRegexLiteral", "isRegExpLiteral");
   if (!node) return false;
 
-  if ((node as t.Node).type !== "RegexLiteral") return false;
+  if (node.type !== "RegexLiteral") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
@@ -3986,13 +3994,13 @@ export function isRegexLiteral(
  * @deprecated Use `isRestElement`
  */
 export function isRestProperty(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.RestProperty> | null,
 ): boolean {
   deprecationWarning("isRestProperty", "isRestElement");
   if (!node) return false;
 
-  if ((node as t.Node).type !== "RestProperty") return false;
+  if (node.type !== "RestProperty") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
@@ -4000,13 +4008,13 @@ export function isRestProperty(
  * @deprecated Use `isSpreadElement`
  */
 export function isSpreadProperty(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.SpreadProperty> | null,
 ): boolean {
   deprecationWarning("isSpreadProperty", "isSpreadElement");
   if (!node) return false;
 
-  if ((node as t.Node).type !== "SpreadProperty") return false;
+  if (node.type !== "SpreadProperty") return false;
 
   return opts == null || shallowEqual(node, opts);
 }
@@ -4014,8 +4022,8 @@ export function isSpreadProperty(
  * @deprecated Use `isImportOrExportDeclaration`
  */
 export function isModuleDeclaration(
-  node: object | null | undefined,
-  opts?: object | null,
+  node: t.Node | null | undefined,
+  opts?: Opts<t.ModuleDeclaration> | null,
 ): node is t.ImportOrExportDeclaration {
   deprecationWarning("isModuleDeclaration", "isImportOrExportDeclaration");
   return isImportOrExportDeclaration(node, opts);

From bc4f7c809dee25ef8848b46b85acd43f1ec9eaf8 Mon Sep 17 00:00:00 2001
From: liuxingbaoyu <30521560+liuxingbaoyu@users.noreply.github.com>
Date: Sun, 21 May 2023 21:03:28 +0800
Subject: [PATCH 6/6] improve

---
 .../scripts/generators/validators.js          | 10 ++-
 .../src/validators/generated/index.ts         | 75 +++----------------
 2 files changed, 21 insertions(+), 64 deletions(-)

diff --git a/packages/babel-types/scripts/generators/validators.js b/packages/babel-types/scripts/generators/validators.js
index 0dc7d5ea447a..870423f5bc9b 100644
--- a/packages/babel-types/scripts/generators/validators.js
+++ b/packages/babel-types/scripts/generators/validators.js
@@ -28,7 +28,12 @@ function addIsHelper(type, aliasKeys, deprecated) {
   if (has(PLACEHOLDERS_FLIPPED_ALIAS, type)) {
     placeholderTypes.push(...PLACEHOLDERS_FLIPPED_ALIAS[type]);
   }
-  if (placeholderTypes.length > 0) {
+  if (placeholderTypes.length === 1) {
+    cases += `
+    case "Placeholder":
+      if (node.expectedNode === ${JSON.stringify(placeholderTypes[0])})
+      break;`;
+  } else if (placeholderTypes.length) {
     cases += `
     case "Placeholder":
       switch (node.expectedNode) {
@@ -69,6 +74,9 @@ export default function generateValidators() {
  * This file is auto-generated! Do not modify it directly.
  * To re-generate run 'make build'
  */
+
+  /* eslint-disable no-fallthrough */
+
 import shallowEqual from "../../utils/shallowEqual";
 import type * as t from "../..";
 import deprecationWarning from "../../utils/deprecationWarning";
diff --git a/packages/babel-types/src/validators/generated/index.ts b/packages/babel-types/src/validators/generated/index.ts
index 38a3c73a48d5..0933f7fa883d 100644
--- a/packages/babel-types/src/validators/generated/index.ts
+++ b/packages/babel-types/src/validators/generated/index.ts
@@ -2,6 +2,9 @@
  * This file is auto-generated! Do not modify it directly.
  * To re-generate run 'make build'
  */
+
+/* eslint-disable no-fallthrough */
+
 import shallowEqual from "../../utils/shallowEqual";
 import type * as t from "../..";
 import deprecationWarning from "../../utils/deprecationWarning";
@@ -2735,13 +2738,7 @@ export function isScopable(
     case "TSModuleBlock":
       break;
     case "Placeholder":
-      switch (node.expectedNode) {
-        case "BlockStatement":
-          break;
-        default:
-          return false;
-      }
-      break;
+      if (node.expectedNode === "BlockStatement") break;
     default:
       return false;
   }
@@ -2774,13 +2771,7 @@ export function isBlockParent(
     case "TSModuleBlock":
       break;
     case "Placeholder":
-      switch (node.expectedNode) {
-        case "BlockStatement":
-          break;
-        default:
-          return false;
-      }
-      break;
+      if (node.expectedNode === "BlockStatement") break;
     default:
       return false;
   }
@@ -2799,13 +2790,7 @@ export function isBlock(
     case "TSModuleBlock":
       break;
     case "Placeholder":
-      switch (node.expectedNode) {
-        case "BlockStatement":
-          break;
-        default:
-          return false;
-      }
-      break;
+      if (node.expectedNode === "BlockStatement") break;
     default:
       return false;
   }
@@ -3083,13 +3068,7 @@ export function isPureish(
     case "DecimalLiteral":
       break;
     case "Placeholder":
-      switch (node.expectedNode) {
-        case "StringLiteral":
-          break;
-        default:
-          return false;
-      }
-      break;
+      if (node.expectedNode === "StringLiteral") break;
     default:
       return false;
   }
@@ -3131,13 +3110,7 @@ export function isDeclaration(
     case "TSModuleDeclaration":
       break;
     case "Placeholder":
-      switch (node.expectedNode) {
-        case "Declaration":
-          break;
-        default:
-          return false;
-      }
-      break;
+      if (node.expectedNode === "Declaration") break;
     default:
       return false;
   }
@@ -3221,13 +3194,7 @@ export function isTSEntityName(
     case "TSQualifiedName":
       break;
     case "Placeholder":
-      switch (node.expectedNode) {
-        case "Identifier":
-          break;
-        default:
-          return false;
-      }
-      break;
+      if (node.expectedNode === "Identifier") break;
     default:
       return false;
   }
@@ -3251,13 +3218,7 @@ export function isLiteral(
     case "DecimalLiteral":
       break;
     case "Placeholder":
-      switch (node.expectedNode) {
-        case "StringLiteral":
-          break;
-        default:
-          return false;
-      }
-      break;
+      if (node.expectedNode === "StringLiteral") break;
     default:
       return false;
   }
@@ -3289,13 +3250,7 @@ export function isImmutable(
     case "DecimalLiteral":
       break;
     case "Placeholder":
-      switch (node.expectedNode) {
-        case "StringLiteral":
-          break;
-        default:
-          return false;
-      }
-      break;
+      if (node.expectedNode === "StringLiteral") break;
     default:
       return false;
   }
@@ -3402,13 +3357,7 @@ export function isPattern(
     case "ObjectPattern":
       break;
     case "Placeholder":
-      switch (node.expectedNode) {
-        case "Pattern":
-          break;
-        default:
-          return false;
-      }
-      break;
+      if (node.expectedNode === "Pattern") break;
     default:
       return false;
   }