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 661dbe7aa3db..74d421782d37 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 {
diff --git a/packages/babel-types/scripts/generators/validators.js b/packages/babel-types/scripts/generators/validators.js
index 380043589c89..870423f5bc9b 100644
--- a/packages/babel-types/scripts/generators/validators.js
+++ b/packages/babel-types/scripts/generators/validators.js
@@ -28,10 +28,15 @@ 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":
-      switch ((node as t.Placeholder).expectedNode) {
+      if (node.expectedNode === ${JSON.stringify(placeholderTypes[0])})
+      break;`;
+  } else if (placeholderTypes.length) {
+    cases += `
+    case "Placeholder":
+      switch (node.expectedNode) {
         ${buildCases(placeholderTypes)}
         default:
           return false;
@@ -44,19 +49,19 @@ 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}(node: t.Node | null | undefined, opts?: Opts<t.${type}> | null): ${result} {
     ${deprecated || ""}
     if (!node) return false;
 
     ${
       cases
         ? `
-          switch((node as t.Node).type){
+          switch(node.type){
             ${cases}
             default:
               return false;
           }`
-        : `if ((node as t.Node).type !== ${targetType}) return false;`
+        : `if (node.type !== ${targetType}) return false;`
     }
 
     return opts == null || shallowEqual(node, opts);
@@ -69,10 +74,22 @@ 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";
-\n`;
+
+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];
+}>;
+
+`;
 
   Object.keys(VISITOR_KEYS).forEach(type => {
     output += addIsHelper(type);
@@ -87,16 +104,19 @@ 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}(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 13431217a795..0933f7fa883d 100644
--- a/packages/babel-types/src/validators/generated/index.ts
+++ b/packages/babel-types/src/validators/generated/index.ts
@@ -2,2507 +2,2518 @@
  * 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";
 
+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 +2603,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 +2620,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 +2679,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 +2695,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 +2711,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,13 +2738,7 @@ export function isScopable(
     case "TSModuleBlock":
       break;
     case "Placeholder":
-      switch ((node as t.Placeholder).expectedNode) {
-        case "BlockStatement":
-          break;
-        default:
-          return false;
-      }
-      break;
+      if (node.expectedNode === "BlockStatement") break;
     default:
       return false;
   }
@@ -2741,12 +2746,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,13 +2771,7 @@ export function isBlockParent(
     case "TSModuleBlock":
       break;
     case "Placeholder":
-      switch ((node as t.Placeholder).expectedNode) {
-        case "BlockStatement":
-          break;
-        default:
-          return false;
-      }
-      break;
+      if (node.expectedNode === "BlockStatement") break;
     default:
       return false;
   }
@@ -2780,24 +2779,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) {
-        case "BlockStatement":
-          break;
-        default:
-          return false;
-      }
-      break;
+      if (node.expectedNode === "BlockStatement") break;
     default:
       return false;
   }
@@ -2805,12 +2798,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 +2853,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 +2869,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 +2889,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 +2907,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 +2923,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 +2942,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 +2958,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 +2975,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 +2992,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 +3008,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 +3028,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 +3050,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,13 +3068,7 @@ export function isPureish(
     case "DecimalLiteral":
       break;
     case "Placeholder":
-      switch ((node as t.Placeholder).expectedNode) {
-        case "StringLiteral":
-          break;
-        default:
-          return false;
-      }
-      break;
+      if (node.expectedNode === "StringLiteral") break;
     default:
       return false;
   }
@@ -3089,12 +3076,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,13 +3110,7 @@ export function isDeclaration(
     case "TSModuleDeclaration":
       break;
     case "Placeholder":
-      switch ((node as t.Placeholder).expectedNode) {
-        case "Declaration":
-          break;
-        default:
-          return false;
-      }
-      break;
+      if (node.expectedNode === "Declaration") break;
     default:
       return false;
   }
@@ -3137,12 +3118,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 +3135,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 +3150,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 +3169,7 @@ export function isLVal(
     case "TSNonNullExpression":
       break;
     case "Placeholder":
-      switch ((node as t.Placeholder).expectedNode) {
+      switch (node.expectedNode) {
         case "Pattern":
         case "Identifier":
           break;
@@ -3203,23 +3184,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) {
-        case "Identifier":
-          break;
-        default:
-          return false;
-      }
-      break;
+      if (node.expectedNode === "Identifier") break;
     default:
       return false;
   }
@@ -3227,12 +3202,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,13 +3218,7 @@ export function isLiteral(
     case "DecimalLiteral":
       break;
     case "Placeholder":
-      switch ((node as t.Placeholder).expectedNode) {
-        case "StringLiteral":
-          break;
-        default:
-          return false;
-      }
-      break;
+      if (node.expectedNode === "StringLiteral") break;
     default:
       return false;
   }
@@ -3257,12 +3226,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,13 +3250,7 @@ export function isImmutable(
     case "DecimalLiteral":
       break;
     case "Placeholder":
-      switch ((node as t.Placeholder).expectedNode) {
-        case "StringLiteral":
-          break;
-        default:
-          return false;
-      }
-      break;
+      if (node.expectedNode === "StringLiteral") break;
     default:
       return false;
   }
@@ -3295,12 +3258,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 +3279,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 +3296,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 +3312,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 +3330,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,24 +3346,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) {
-        case "Pattern":
-          break;
-        default:
-          return false;
-      }
-      break;
+      if (node.expectedNode === "Pattern") break;
     default:
       return false;
   }
@@ -3408,12 +3365,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 +3381,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 +3399,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 +3416,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 +3436,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 +3451,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 +3468,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 +3547,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 +3587,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 +3611,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 +3638,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 +3654,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 +3672,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 +3690,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 +3719,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 +3736,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 +3815,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 +3834,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 +3883,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":
@@ -3954,53 +3911,68 @@ export function isTSBaseType(
 
   return opts == null || shallowEqual(node, opts);
 }
+/**
+ * @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);
 }
+/**
+ * @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);
 }
+/**
+ * @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);
 }
+/**
+ * @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);
 }
+/**
+ * @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);