diff --git a/codemods/babel-plugin-codemod-object-assign-to-object-spread/src/index.ts b/codemods/babel-plugin-codemod-object-assign-to-object-spread/src/index.ts
index cb7ae05910d8..50a18d9bd0b0 100644
--- a/codemods/babel-plugin-codemod-object-assign-to-object-spread/src/index.ts
+++ b/codemods/babel-plugin-codemod-object-assign-to-object-spread/src/index.ts
@@ -1,6 +1,7 @@
 import syntaxObjectRestSpread from "@babel/plugin-syntax-object-rest-spread";
+import type { PluginAPI, PluginObject } from "@babel/core";
 
-export default function ({ types: t }) {
+export default function ({ types: t }: PluginAPI): PluginObject {
   return {
     inherits: syntaxObjectRestSpread.default,
 
@@ -21,10 +22,15 @@ export default function ({ types: t }) {
           const arg = args[i];
           const { node } = arg;
 
-          if (arg.isObjectExpression()) {
+          if (t.isObjectExpression(node)) {
             properties.push(...node.properties);
           } else {
-            properties.push(t.spreadElement(node));
+            properties.push(
+              t.spreadElement(
+                // @ts-expect-error fixme
+                node,
+              ),
+            );
           }
         }
 
diff --git a/codemods/babel-plugin-codemod-optional-catch-binding/src/index.ts b/codemods/babel-plugin-codemod-optional-catch-binding/src/index.ts
index d4873469bb7a..9cf2954e0e58 100644
--- a/codemods/babel-plugin-codemod-optional-catch-binding/src/index.ts
+++ b/codemods/babel-plugin-codemod-optional-catch-binding/src/index.ts
@@ -1,6 +1,7 @@
 import syntaxOptionalCatchBinding from "@babel/plugin-syntax-optional-catch-binding";
+import type { PluginAPI, PluginObject } from "@babel/core";
 
-export default function ({ types: t }) {
+export default function ({ types: t }: PluginAPI): PluginObject {
   return {
     inherits: syntaxOptionalCatchBinding.default,
 
diff --git a/lib/regexpu-core.d.ts b/lib/regexpu-core.d.ts
new file mode 100644
index 000000000000..415800a5196c
--- /dev/null
+++ b/lib/regexpu-core.d.ts
@@ -0,0 +1,17 @@
+declare module "regexpu-core" {
+  type RegexpuOptions = {
+    unicodeFlag?: "transform" | false;
+    unicodeSetsFlag?: "transform" | "parse" | false;
+    dotAllFlag?: "transform" | false;
+    unicodePropertyEscapes?: "transform" | false;
+    namedGroups?: "transform" | false;
+    onNamedGroup?: (name: string, index: number) => void;
+  };
+  function rewritePattern(
+    pattern: string,
+    flags: string,
+    options: RegexpuOptions
+  ): string;
+  export = rewritePattern;
+  export { RegexpuOptions };
+}
diff --git a/packages/babel-code-frame/src/index.ts b/packages/babel-code-frame/src/index.ts
index 35c26501c5bc..db5b7de65c2e 100644
--- a/packages/babel-code-frame/src/index.ts
+++ b/packages/babel-code-frame/src/index.ts
@@ -1,5 +1,7 @@
 import highlight, { shouldHighlight, getChalk } from "@babel/highlight";
 
+type Chalk = ReturnType<typeof getChalk>;
+
 let deprecationWarningShown = false;
 
 type Location = {
@@ -37,7 +39,7 @@ export interface Options {
 /**
  * Chalk styles for code frame token types.
  */
-function getDefs(chalk) {
+function getDefs(chalk: Chalk) {
   return {
     gutter: chalk.grey,
     marker: chalk.red.bold,
@@ -55,6 +57,8 @@ const NEWLINE = /\r\n|[\n\r\u2028\u2029]/;
  * Extract what lines should be marked and highlighted.
  */
 
+type MarkerLines = Record<number, true | [number, number]>;
+
 function getMarkerLines(
   loc: NodeLocation,
   source: Array<string>,
@@ -62,7 +66,7 @@ function getMarkerLines(
 ): {
   start: number;
   end: number;
-  markerLines: any;
+  markerLines: MarkerLines;
 } {
   const startLoc: Location = {
     column: 0,
@@ -91,7 +95,7 @@ function getMarkerLines(
   }
 
   const lineDiff = endLine - startLine;
-  const markerLines = {};
+  const markerLines: MarkerLines = {};
 
   if (lineDiff) {
     for (let i = 0; i <= lineDiff; i++) {
@@ -135,7 +139,7 @@ export function codeFrameColumns(
     (opts.highlightCode || opts.forceColor) && shouldHighlight(opts);
   const chalk = getChalk(opts);
   const defs = getDefs(chalk);
-  const maybeHighlight = (chalkFn, string) => {
+  const maybeHighlight = (chalkFn: Chalk, string: string) => {
     return highlighted ? chalkFn(string) : string;
   };
   const lines = rawLines.split(NEWLINE);
diff --git a/packages/babel-core/src/config/cache-contexts.ts b/packages/babel-core/src/config/cache-contexts.ts
index b487d22dfcb3..1c7e1553bac3 100644
--- a/packages/babel-core/src/config/cache-contexts.ts
+++ b/packages/babel-core/src/config/cache-contexts.ts
@@ -16,7 +16,7 @@ export type FullPlugin = {
 // process 'ignore'/'only' and other filename-based logic.
 export type SimpleConfig = {
   envName: string;
-  caller: CallerMetadata | void;
+  caller: CallerMetadata | undefined;
 };
 export type SimplePreset = {
   targets: Targets;
diff --git a/packages/babel-core/src/config/caching.ts b/packages/babel-core/src/config/caching.ts
index 2cd59d5f1c02..5575ff78b231 100644
--- a/packages/babel-core/src/config/caching.ts
+++ b/packages/babel-core/src/config/caching.ts
@@ -348,7 +348,7 @@ class CacheConfigurator<SideChannel = void> {
 function makeSimpleConfigurator(
   cache: CacheConfigurator<any>,
 ): SimpleCacheConfigurator {
-  function cacheFn(val) {
+  function cacheFn(val: any) {
     if (typeof val === "boolean") {
       if (val) cache.forever();
       else cache.never();
@@ -359,8 +359,10 @@ function makeSimpleConfigurator(
   }
   cacheFn.forever = () => cache.forever();
   cacheFn.never = () => cache.never();
-  cacheFn.using = cb => cache.using(() => assertSimpleType(cb()));
-  cacheFn.invalidate = cb => cache.invalidate(() => assertSimpleType(cb()));
+  cacheFn.using = (cb: { (): SimpleType }) =>
+    cache.using(() => assertSimpleType(cb()));
+  cacheFn.invalidate = (cb: { (): SimpleType }) =>
+    cache.invalidate(() => assertSimpleType(cb()));
 
   return cacheFn as any;
 }
diff --git a/packages/babel-core/src/config/config-chain.ts b/packages/babel-core/src/config/config-chain.ts
index 059d38034b52..b3f8e4139400 100644
--- a/packages/babel-core/src/config/config-chain.ts
+++ b/packages/babel-core/src/config/config-chain.ts
@@ -55,7 +55,7 @@ export type ConfigContext = {
   cwd: string;
   root: string;
   envName: string;
-  caller: CallerMetadata | void;
+  caller: CallerMetadata | undefined;
   showConfig: boolean;
 };
 
@@ -383,7 +383,12 @@ const loadFileChainWalker = makeChainWalker<ValidatedFile>({
     buildFileLogger(file.filepath, context, baseLogger),
 });
 
-function* loadFileChain(input, context, files, baseLogger) {
+function* loadFileChain(
+  input: ValidatedFile,
+  context: ConfigContext,
+  files: Set<ConfigFile>,
+  baseLogger: ConfigPrinter,
+) {
   const chain = yield* loadFileChainWalker(input, context, files, baseLogger);
   if (chain) {
     chain.files.add(input.filepath);
@@ -443,11 +448,23 @@ function buildFileLogger(
   });
 }
 
-function buildRootDescriptors({ dirname, options }, alias, descriptors) {
+function buildRootDescriptors(
+  { dirname, options }: Partial<ValidatedFile>,
+  alias: string,
+  descriptors: (
+    dirname: string,
+    options: ValidatedOptions,
+    alias: string,
+  ) => OptionsAndDescriptors,
+) {
   return descriptors(dirname, options, alias);
 }
 
-function buildProgrammaticLogger(_, context, baseLogger: ConfigPrinter | void) {
+function buildProgrammaticLogger(
+  _: unknown,
+  context: ConfigContext,
+  baseLogger: ConfigPrinter | void,
+) {
   if (!baseLogger) {
     return () => {};
   }
@@ -457,20 +474,28 @@ function buildProgrammaticLogger(_, context, baseLogger: ConfigPrinter | void) {
 }
 
 function buildEnvDescriptors(
-  { dirname, options },
-  alias,
-  descriptors,
-  envName,
+  { dirname, options }: Partial<ValidatedFile>,
+  alias: string,
+  descriptors: (
+    dirname: string,
+    options: ValidatedOptions,
+    alias: string,
+  ) => OptionsAndDescriptors,
+  envName: string,
 ) {
   const opts = options.env && options.env[envName];
   return opts ? descriptors(dirname, opts, `${alias}.env["${envName}"]`) : null;
 }
 
 function buildOverrideDescriptors(
-  { dirname, options },
-  alias,
-  descriptors,
-  index,
+  { dirname, options }: Partial<ValidatedFile>,
+  alias: string,
+  descriptors: (
+    dirname: string,
+    options: ValidatedOptions,
+    alias: string,
+  ) => OptionsAndDescriptors,
+  index: number,
 ) {
   const opts = options.overrides && options.overrides[index];
   if (!opts) throw new Error("Assertion failure - missing override");
@@ -479,11 +504,15 @@ function buildOverrideDescriptors(
 }
 
 function buildOverrideEnvDescriptors(
-  { dirname, options },
-  alias,
-  descriptors,
-  index,
-  envName,
+  { dirname, options }: Partial<ValidatedFile>,
+  alias: string,
+  descriptors: (
+    dirname: string,
+    options: ValidatedOptions,
+    alias: string,
+  ) => OptionsAndDescriptors,
+  index: number,
+  envName: string,
 ) {
   const override = options.overrides && options.overrides[index];
   if (!override) throw new Error("Assertion failure - missing override");
@@ -850,9 +879,9 @@ function matchesPatterns(
 }
 
 function matchPattern(
-  pattern,
-  dirname,
-  pathToTest,
+  pattern: IgnoreItem,
+  dirname: string,
+  pathToTest: unknown,
   context: ConfigContext,
 ): boolean {
   if (typeof pattern === "function") {
diff --git a/packages/babel-core/src/config/config-descriptors.ts b/packages/babel-core/src/config/config-descriptors.ts
index 9fe9df54a027..fe033eccc4aa 100644
--- a/packages/babel-core/src/config/config-descriptors.ts
+++ b/packages/babel-core/src/config/config-descriptors.ts
@@ -126,8 +126,8 @@ export function createUncachedDescriptors(
   // The returned result here is cached to represent a config object in
   // memory, so we build and memoize the descriptors to ensure the same
   // values are returned consistently.
-  let plugins;
-  let presets;
+  let plugins: UnloadedDescriptor[];
+  let presets: UnloadedDescriptor[];
 
   return {
     options: optionsWithResolvedBrowserslistConfigFile(options, dirname),
diff --git a/packages/babel-core/src/config/files/configuration.ts b/packages/babel-core/src/config/files/configuration.ts
index 713e0c355ab2..23104ea7ce4e 100644
--- a/packages/babel-core/src/config/files/configuration.ts
+++ b/packages/babel-core/src/config/files/configuration.ts
@@ -57,7 +57,7 @@ export function findConfigUpwards(rootDir: string): string | null {
 export function* findRelativeConfig(
   packageData: FilePackageData,
   envName: string,
-  caller: CallerMetadata | void,
+  caller: CallerMetadata | undefined,
 ): Handler<RelativeConfig> {
   let config = null;
   let ignore = null;
@@ -93,7 +93,7 @@ export function* findRelativeConfig(
 export function findRootConfig(
   dirname: string,
   envName: string,
-  caller: CallerMetadata | void,
+  caller: CallerMetadata | undefined,
 ): Handler<ConfigFile | null> {
   return loadOneConfig(ROOT_CONFIG_FILENAMES, dirname, envName, caller);
 }
@@ -102,7 +102,7 @@ function* loadOneConfig(
   names: string[],
   dirname: string,
   envName: string,
-  caller: CallerMetadata | void,
+  caller: CallerMetadata | undefined,
   previousConfig: ConfigFile | null = null,
 ): Handler<ConfigFile | null> {
   const configs = yield* gensync.all(
@@ -133,7 +133,7 @@ export function* loadConfig(
   name: string,
   dirname: string,
   envName: string,
-  caller: CallerMetadata | void,
+  caller: CallerMetadata | undefined,
 ): Handler<ConfigFile> {
   const filepath = require.resolve(name, { paths: [dirname] });
 
@@ -150,7 +150,11 @@ export function* loadConfig(
  * Read the given config file, returning the result. Returns null if no config was found, but will
  * throw if there are parsing errors while loading a config.
  */
-function readConfig(filepath, envName, caller): Handler<ConfigFile | null> {
+function readConfig(
+  filepath: string,
+  envName: string,
+  caller: CallerMetadata | undefined,
+): Handler<ConfigFile | null> {
   const ext = path.extname(filepath);
   return ext === ".js" || ext === ".cjs" || ext === ".mjs"
     ? readConfigJS(filepath, { envName, caller })
@@ -163,7 +167,7 @@ const readConfigJS = makeStrongCache(function* readConfigJS(
   filepath: string,
   cache: CacheConfigurator<{
     envName: string;
-    caller: CallerMetadata | void;
+    caller: CallerMetadata | undefined;
   }>,
 ): Handler<ConfigFile | null> {
   if (!nodeFs.existsSync(filepath)) {
diff --git a/packages/babel-core/src/config/files/import-meta-resolve.ts b/packages/babel-core/src/config/files/import-meta-resolve.ts
index 11c9731aa912..591aec4d9de4 100644
--- a/packages/babel-core/src/config/files/import-meta-resolve.ts
+++ b/packages/babel-core/src/config/files/import-meta-resolve.ts
@@ -34,7 +34,8 @@ const importMetaResolveP: Promise<ImportMeta["resolve"]> =
   // it throws because it's a module, will fallback to import().
   process.execArgv.includes("--experimental-import-meta-resolve")
     ? import_("data:text/javascript,export default import.meta.resolve").then(
-        m => m.default || polyfill,
+        (m: { default: ImportMeta["resolve"] | undefined }) =>
+          m.default || polyfill,
         () => polyfill,
       )
     : Promise.resolve(polyfill);
diff --git a/packages/babel-core/src/config/files/index-browser.ts b/packages/babel-core/src/config/files/index-browser.ts
index ac615d9a1583..08f91f6a6751 100644
--- a/packages/babel-core/src/config/files/index-browser.ts
+++ b/packages/babel-core/src/config/files/index-browser.ts
@@ -35,7 +35,7 @@ export function* findRelativeConfig(
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
   envName: string,
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  caller: CallerMetadata | void,
+  caller: CallerMetadata | undefined,
 ): Handler<RelativeConfig> {
   return { config: null, ignore: null };
 }
@@ -47,7 +47,7 @@ export function* findRootConfig(
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
   envName: string,
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  caller: CallerMetadata | void,
+  caller: CallerMetadata | undefined,
 ): Handler<ConfigFile | null> {
   return null;
 }
@@ -59,7 +59,7 @@ export function* loadConfig(
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
   envName: string,
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  caller: CallerMetadata | void,
+  caller: CallerMetadata | undefined,
 ): Handler<ConfigFile> {
   throw new Error(`Cannot load ${name} relative to ${dirname} in a browser`);
 }
@@ -72,7 +72,7 @@ export function* resolveShowConfigPath(
   return null;
 }
 
-export const ROOT_CONFIG_FILENAMES = [];
+export const ROOT_CONFIG_FILENAMES: string[] = [];
 
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 export function resolvePlugin(name: string, dirname: string): string | null {
diff --git a/packages/babel-core/src/config/files/module-types.ts b/packages/babel-core/src/config/files/module-types.ts
index 711c0f60079d..7ece0a7a8906 100644
--- a/packages/babel-core/src/config/files/module-types.ts
+++ b/packages/babel-core/src/config/files/module-types.ts
@@ -7,7 +7,7 @@ import semver from "semver";
 
 const require = createRequire(import.meta.url);
 
-let import_;
+let import_: ((specifier: string | URL) => any) | undefined;
 try {
   // Old Node.js versions don't support import() syntax.
   import_ = require("./import").default;
diff --git a/packages/babel-core/src/config/files/types.ts b/packages/babel-core/src/config/files/types.ts
index a2e61f7ef7e5..3edf65b58f69 100644
--- a/packages/babel-core/src/config/files/types.ts
+++ b/packages/babel-core/src/config/files/types.ts
@@ -1,7 +1,9 @@
+import type { InputOptions } from "..";
+
 export type ConfigFile = {
   filepath: string;
   dirname: string;
-  options: {};
+  options: InputOptions & { babel?: unknown };
 };
 
 export type IgnoreFile = {
diff --git a/packages/babel-core/src/config/full.ts b/packages/babel-core/src/config/full.ts
index 7121d4892902..abb022927652 100644
--- a/packages/babel-core/src/config/full.ts
+++ b/packages/babel-core/src/config/full.ts
@@ -181,7 +181,7 @@ export default gensync<(inputOpts: unknown) => ResolvedConfig | null>(
       pluginDescriptorsByPass[0].unshift(...initialPluginsDescriptors);
 
       for (const descs of pluginDescriptorsByPass) {
-        const pass = [];
+        const pass: Plugin[] = [];
         passes.push(pass);
 
         for (let i = 0; i < descs.length; i++) {
@@ -223,8 +223,8 @@ export default gensync<(inputOpts: unknown) => ResolvedConfig | null>(
   },
 );
 
-function enhanceError<T extends Function>(context, fn: T): T {
-  return function* (arg1, arg2) {
+function enhanceError<T extends Function>(context: ConfigContext, fn: T): T {
+  return function* (arg1: unknown, arg2: unknown) {
     try {
       return yield* fn(arg1, arg2);
     } catch (e) {
@@ -376,7 +376,7 @@ const instantiatePlugin = makeWeakCache(function* (
   }
 
   if (plugin.inherits) {
-    const inheritsDescriptor = {
+    const inheritsDescriptor: UnloadedDescriptor = {
       name: undefined,
       alias: `${alias}$inherits`,
       value: plugin.inherits,
@@ -490,11 +490,14 @@ const instantiatePreset = makeWeakCacheSync(
   },
 );
 
-function chain(a, b) {
+function chain<Args extends any[]>(
+  a: undefined | ((...args: Args) => void),
+  b: undefined | ((...args: Args) => void),
+) {
   const fns = [a, b].filter(Boolean);
   if (fns.length <= 1) return fns[0];
 
-  return function (this: unknown, ...args) {
+  return function (this: unknown, ...args: unknown[]) {
     for (const fn of fns) {
       fn.apply(this, args);
     }
diff --git a/packages/babel-core/src/config/helpers/config-api.ts b/packages/babel-core/src/config/helpers/config-api.ts
index b8f8ba833c3b..724fdc431873 100644
--- a/packages/babel-core/src/config/helpers/config-api.ts
+++ b/packages/babel-core/src/config/helpers/config-api.ts
@@ -21,10 +21,10 @@ type EnvFunction = {
 };
 
 type CallerFactory = (
-  extractor: (callerMetadata: CallerMetadata | void) => unknown,
+  extractor: (callerMetadata: CallerMetadata | undefined) => unknown,
 ) => SimpleType;
 type TargetsFunction = () => Targets;
-type AssumptionFunction = (name: AssumptionName) => boolean | void;
+type AssumptionFunction = (name: AssumptionName) => boolean | undefined;
 
 export type ConfigAPI = {
   version: string;
@@ -47,23 +47,29 @@ export type PluginAPI = {
 export function makeConfigAPI<SideChannel extends Context.SimpleConfig>(
   cache: CacheConfigurator<SideChannel>,
 ): ConfigAPI {
-  const env: any = value =>
+  // TODO(@nicolo-ribaudo): If we remove the explicit type from `value`
+  // and the `as any` type cast, TypeScript crashes in an infinite
+  // recursion. After upgrading to TS4.7 and finishing the noImplicitAny
+  // PR, we should check if it still crashes and report it to the TS team.
+  const env: EnvFunction = ((
+    value: string | string[] | (<T>(babelEnv: string) => T),
+  ) =>
     cache.using(data => {
       if (typeof value === "undefined") return data.envName;
       if (typeof value === "function") {
         return assertSimpleType(value(data.envName));
       }
-      if (!Array.isArray(value)) value = [value];
-
-      return value.some((entry: unknown) => {
+      return (Array.isArray(value) ? value : [value]).some(entry => {
         if (typeof entry !== "string") {
           throw new Error("Unexpected non-string value");
         }
         return entry === data.envName;
       });
-    });
+    })) as any;
 
-  const caller = cb => cache.using(data => assertSimpleType(cb(data.caller)));
+  const caller = (cb: {
+    (CallerMetadata: CallerMetadata | undefined): SimpleType;
+  }) => cache.using(data => assertSimpleType(cb(data.caller)));
 
   return {
     version: coreVersion,
@@ -98,7 +104,8 @@ export function makePluginAPI<SideChannel extends Context.SimplePlugin>(
   cache: CacheConfigurator<SideChannel>,
   externalDependencies: Array<string>,
 ): PluginAPI {
-  const assumption = name => cache.using(data => data.assumptions[name]);
+  const assumption = (name: string) =>
+    cache.using(data => data.assumptions[name]);
 
   return { ...makePresetAPI(cache, externalDependencies), assumption };
 }
diff --git a/packages/babel-core/src/config/index.ts b/packages/babel-core/src/config/index.ts
index d231a8ec6d59..c01b90ca1c83 100644
--- a/packages/babel-core/src/config/index.ts
+++ b/packages/babel-core/src/config/index.ts
@@ -1,4 +1,5 @@
 import gensync from "gensync";
+import type { Gensync } from "gensync";
 
 export type {
   ResolvedConfig,
@@ -18,9 +19,12 @@ type PluginAPI = basePluginAPI & typeof import("..");
 type PresetAPI = basePresetAPI & typeof import("..");
 export type { PluginAPI, PresetAPI };
 // todo: may need to refine PresetObject to be a subset of ValidatedOptions
-export type { ValidatedOptions as PresetObject } from "./validation/options";
+export type {
+  CallerMetadata,
+  ValidatedOptions as PresetObject,
+} from "./validation/options";
 
-import loadFullConfig from "./full";
+import loadFullConfig, { type ResolvedConfig } from "./full";
 import { loadPartialConfig as loadPartialConfigRunner } from "./partial";
 
 export { loadFullConfig as default };
@@ -29,24 +33,28 @@ export type { PartialConfig } from "./partial";
 import { createConfigItem as createConfigItemImpl } from "./item";
 import type { ConfigItem } from "./item";
 
-const loadOptionsRunner = gensync<(opts: unknown) => any>(function* (opts) {
-  const config = yield* loadFullConfig(opts);
-  // NOTE: We want to return "null" explicitly, while ?. alone returns undefined
-  return config?.options ?? null;
-});
+const loadOptionsRunner = gensync<(opts: unknown) => ResolvedConfig | null>(
+  function* (opts) {
+    const config = yield* loadFullConfig(opts);
+    // NOTE: We want to return "null" explicitly, while ?. alone returns undefined
+    return config?.options ?? null;
+  },
+);
 
 const createConfigItemRunner =
   gensync<(...args: Parameters<typeof createConfigItemImpl>) => ConfigItem>(
     createConfigItemImpl,
   );
 
-const maybeErrback = runner => (opts: unknown, callback?: Function) => {
-  if (callback === undefined && typeof opts === "function") {
-    callback = opts;
-    opts = undefined;
-  }
-  return callback ? runner.errback(opts, callback) : runner.sync(opts);
-};
+const maybeErrback =
+  (runner: Gensync<(...args: any) => any>) =>
+  (opts: unknown, callback?: any) => {
+    if (callback === undefined && typeof opts === "function") {
+      callback = opts;
+      opts = undefined;
+    }
+    return callback ? runner.errback(opts, callback) : runner.sync(opts);
+  };
 
 export const loadPartialConfig = maybeErrback(loadPartialConfigRunner);
 export const loadPartialConfigSync = loadPartialConfigRunner.sync;
@@ -60,7 +68,7 @@ export const createConfigItemSync = createConfigItemRunner.sync;
 export const createConfigItemAsync = createConfigItemRunner.async;
 export function createConfigItem(
   target: PluginTarget,
-  options: any,
+  options: Parameters<typeof createConfigItemImpl>[1],
   callback?: (err: Error, val: ConfigItem | null) => void,
 ) {
   if (callback !== undefined) {
diff --git a/packages/babel-core/src/config/pattern-to-regex.ts b/packages/babel-core/src/config/pattern-to-regex.ts
index a5078365fdcd..714207f8700e 100644
--- a/packages/babel-core/src/config/pattern-to-regex.ts
+++ b/packages/babel-core/src/config/pattern-to-regex.ts
@@ -11,7 +11,7 @@ const starPatLast = `(?:${substitution}${endSep})`;
 const starStarPat = `${starPat}*?`;
 const starStarPatLast = `${starPat}*?${starPatLast}?`;
 
-function escapeRegExp(string) {
+function escapeRegExp(string: string) {
   return string.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&");
 }
 
diff --git a/packages/babel-core/src/config/plugin.ts b/packages/babel-core/src/config/plugin.ts
index ea10bb8c7eaa..782b57ec6175 100644
--- a/packages/babel-core/src/config/plugin.ts
+++ b/packages/babel-core/src/config/plugin.ts
@@ -5,9 +5,9 @@ import type { PluginObject } from "./validation/plugins";
 export default class Plugin {
   key: string | undefined | null;
   manipulateOptions?: (options: unknown, parserOpts: unknown) => void;
-  post?: Function;
-  pre?: Function;
-  visitor: {};
+  post?: PluginObject["post"];
+  pre?: PluginObject["pre"];
+  visitor: PluginObject["visitor"];
 
   parserOverride?: Function;
   generatorOverride?: Function;
diff --git a/packages/babel-core/src/config/resolve-targets-browser.ts b/packages/babel-core/src/config/resolve-targets-browser.ts
index 2d91c9216975..60745dd7dca6 100644
--- a/packages/babel-core/src/config/resolve-targets-browser.ts
+++ b/packages/babel-core/src/config/resolve-targets-browser.ts
@@ -1,5 +1,7 @@
 import type { ValidatedOptions } from "./validation/options";
-import getTargets from "@babel/helper-compilation-targets";
+import getTargets, {
+  type InputTargets,
+} from "@babel/helper-compilation-targets";
 
 import type { Targets } from "@babel/helper-compilation-targets";
 
@@ -17,13 +19,18 @@ export function resolveTargets(
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
   root: string,
 ): Targets {
-  // todo(flow->ts) remove any and refactor to not assign different types into same variable
-  let targets: any = options.targets;
-  if (typeof targets === "string" || Array.isArray(targets)) {
-    targets = { browsers: targets };
-  }
-  if (targets && targets.esmodules) {
-    targets = { ...targets, esmodules: "intersect" };
+  const optTargets = options.targets;
+  let targets: InputTargets;
+
+  if (typeof optTargets === "string" || Array.isArray(optTargets)) {
+    targets = { browsers: optTargets };
+  } else if (optTargets) {
+    if ("esmodules" in optTargets) {
+      targets = { ...optTargets, esmodules: "intersect" };
+    } else {
+      // https://github.com/microsoft/TypeScript/issues/17002
+      targets = optTargets as InputTargets;
+    }
   }
 
   return getTargets(targets, {
diff --git a/packages/babel-core/src/config/resolve-targets.ts b/packages/babel-core/src/config/resolve-targets.ts
index 90a443ed3387..a7d9a790e99a 100644
--- a/packages/babel-core/src/config/resolve-targets.ts
+++ b/packages/babel-core/src/config/resolve-targets.ts
@@ -7,7 +7,9 @@ type nodeType = typeof import("./resolve-targets");
 
 import type { ValidatedOptions } from "./validation/options";
 import path from "path";
-import getTargets from "@babel/helper-compilation-targets";
+import getTargets, {
+  type InputTargets,
+} from "@babel/helper-compilation-targets";
 
 import type { Targets } from "@babel/helper-compilation-targets";
 
@@ -22,13 +24,18 @@ export function resolveTargets(
   options: ValidatedOptions,
   root: string,
 ): Targets {
-  // todo(flow->ts) remove any and refactor to not assign different types into same variable
-  let targets: any = options.targets;
-  if (typeof targets === "string" || Array.isArray(targets)) {
-    targets = { browsers: targets };
-  }
-  if (targets && targets.esmodules) {
-    targets = { ...targets, esmodules: "intersect" };
+  const optTargets = options.targets;
+  let targets: InputTargets;
+
+  if (typeof optTargets === "string" || Array.isArray(optTargets)) {
+    targets = { browsers: optTargets };
+  } else if (optTargets) {
+    if ("esmodules" in optTargets) {
+      targets = { ...optTargets, esmodules: "intersect" };
+    } else {
+      // https://github.com/microsoft/TypeScript/issues/17002
+      targets = optTargets as InputTargets;
+    }
   }
 
   const { browserslistConfigFile } = options;
diff --git a/packages/babel-core/src/config/util.ts b/packages/babel-core/src/config/util.ts
index 2bdce13b7071..76c7a7db7171 100644
--- a/packages/babel-core/src/config/util.ts
+++ b/packages/babel-core/src/config/util.ts
@@ -13,16 +13,18 @@ export function mergeOptions(
       const targetObj = target[k] || (target[k] = {});
       mergeDefaultFields(targetObj, parserOpts);
     } else {
+      //@ts-expect-error
       const val = source[k];
+      //@ts-expect-error
       if (val !== undefined) target[k] = val as any;
     }
   }
 }
 
 function mergeDefaultFields<T extends {}>(target: T, source: T) {
-  for (const k of Object.keys(source)) {
+  for (const k of Object.keys(source) as (keyof T)[]) {
     const val = source[k];
-    if (val !== undefined) target[k] = val as any;
+    if (val !== undefined) target[k] = val;
   }
 }
 
diff --git a/packages/babel-core/src/config/validation/option-assertions.ts b/packages/babel-core/src/config/validation/option-assertions.ts
index 8f141a1c160a..50c40c63633b 100644
--- a/packages/babel-core/src/config/validation/option-assertions.ts
+++ b/packages/babel-core/src/config/validation/option-assertions.ts
@@ -33,7 +33,7 @@ export type ValidatorSet = {
 
 export type Validator<T> = (loc: OptionPath, value: unknown) => T;
 
-export function msg(loc: NestingPath | GeneralPath) {
+export function msg(loc: NestingPath | GeneralPath): string {
   switch (loc.type) {
     case "root":
       return ``;
@@ -135,7 +135,7 @@ export function assertSourceType(
 export function assertCallerMetadata(
   loc: OptionPath,
   value: unknown,
-): CallerMetadata | void {
+): CallerMetadata | undefined {
   const obj = assertObject(loc, value);
   if (obj) {
     if (typeof obj.name !== "string") {
@@ -446,7 +446,7 @@ function assertBrowserVersion(loc: GeneralPath, value: unknown) {
 
 export function assertAssumptions(
   loc: GeneralPath,
-  value: unknown,
+  value: { [key: string]: unknown },
 ): { [name: string]: boolean } | void {
   if (value === undefined) return;
 
diff --git a/packages/babel-core/src/config/validation/options.ts b/packages/babel-core/src/config/validation/options.ts
index 2b256fd2b8e5..588892994bda 100644
--- a/packages/babel-core/src/config/validation/options.ts
+++ b/packages/babel-core/src/config/validation/options.ts
@@ -296,7 +296,7 @@ export function validate(type: OptionsSource, opts: {}): ValidatedOptions {
   );
 }
 
-function validateNested(loc: NestingPath, opts: {}) {
+function validateNested(loc: NestingPath, opts: { [key: string]: unknown }) {
   const type = getSource(loc);
 
   assertNoDuplicateSourcemap(opts);
diff --git a/packages/babel-core/src/config/validation/plugins.ts b/packages/babel-core/src/config/validation/plugins.ts
index 9364758f153b..0e29a78364b8 100644
--- a/packages/babel-core/src/config/validation/plugins.ts
+++ b/packages/babel-core/src/config/validation/plugins.ts
@@ -14,7 +14,7 @@ import type {
 import type { ParserOptions } from "@babel/parser";
 import type { Visitor } from "@babel/traverse";
 import type { ValidatedOptions } from "./options";
-import type { File, PluginPass } from "../../..";
+import type { File, PluginPass } from "../../index";
 
 // Note: The casts here are just meant to be static assertions to make sure
 // that the assertion functions actually assert that the value's type matches
@@ -92,7 +92,9 @@ export type PluginObject<S extends PluginPass = PluginPass> = {
   generatorOverride?: Function;
 };
 
-export function validatePluginObject(obj: {}): PluginObject {
+export function validatePluginObject(obj: {
+  [key: string]: unknown;
+}): PluginObject {
   const rootPath: RootPath = {
     type: "root",
     source: "plugin",
diff --git a/packages/babel-core/src/gensync-utils/async.ts b/packages/babel-core/src/gensync-utils/async.ts
index 7c5cc1da8101..af3e3da742b6 100644
--- a/packages/babel-core/src/gensync-utils/async.ts
+++ b/packages/babel-core/src/gensync-utils/async.ts
@@ -3,7 +3,7 @@ import gensync from "gensync";
 import type { Gensync, Handler } from "gensync";
 type MaybePromise<T> = T | Promise<T>;
 
-const id = x => x;
+const id = <T>(x: T): T => x;
 
 const runGenerator: {
   sync<Return>(gen: Generator<unknown, Return>): Return;
diff --git a/packages/babel-core/src/index.ts b/packages/babel-core/src/index.ts
index 3a05f67240ce..9698e3fd1a6f 100644
--- a/packages/babel-core/src/index.ts
+++ b/packages/babel-core/src/index.ts
@@ -32,13 +32,20 @@ export {
 } from "./config";
 
 export type {
+  CallerMetadata,
+  InputOptions,
   PluginAPI,
   PluginObject,
   PresetAPI,
   PresetObject,
 } from "./config";
 
-export { transform, transformSync, transformAsync } from "./transform";
+export {
+  transform,
+  transformSync,
+  transformAsync,
+  type FileResult,
+} from "./transform";
 export {
   transformFile,
   transformFileSync,
diff --git a/packages/babel-core/src/parse.ts b/packages/babel-core/src/parse.ts
index 38765f06eebf..49a7587a0781 100644
--- a/packages/babel-core/src/parse.ts
+++ b/packages/babel-core/src/parse.ts
@@ -5,10 +5,11 @@ import type { InputOptions } from "./config";
 import parser from "./parser";
 import type { ParseResult } from "./parser";
 import normalizeOptions from "./transformation/normalize-opts";
+import type { ValidatedOptions } from "./config/validation/options";
 
 type FileParseCallback = {
-  (err: Error, ast: null): any;
-  (err: null, ast: ParseResult | null): any;
+  (err: Error, ast: null): void;
+  (err: null, ast: ParseResult | null): void;
 };
 
 type Parse = {
@@ -33,10 +34,14 @@ const parseRunner = gensync<
   return yield* parser(config.passes, normalizeOptions(config), code);
 });
 
-export const parse: Parse = function parse(code, opts?, callback?) {
+export const parse: Parse = function parse(
+  code,
+  opts?,
+  callback?: FileParseCallback,
+) {
   if (typeof opts === "function") {
     callback = opts;
-    opts = undefined;
+    opts = undefined as ValidatedOptions;
   }
 
   if (callback === undefined) {
diff --git a/packages/babel-core/src/parser/util/missing-plugin-helper.ts b/packages/babel-core/src/parser/util/missing-plugin-helper.ts
index 32f31b7201bd..7726dcd6aaf2 100644
--- a/packages/babel-core/src/parser/util/missing-plugin-helper.ts
+++ b/packages/babel-core/src/parser/util/missing-plugin-helper.ts
@@ -1,4 +1,7 @@
-const pluginNameMap = {
+const pluginNameMap: Record<
+  string,
+  Partial<Record<"syntax" | "transform", Record<"name" | "url", string>>>
+> = {
   asyncDoExpressions: {
     syntax: {
       name: "@babel/plugin-syntax-async-do-expressions",
@@ -291,7 +294,8 @@ const pluginNameMap = {
 //todo: we don't have plugin-syntax-private-property-in-object
 pluginNameMap.privateIn.syntax = pluginNameMap.privateIn.transform;
 
-const getNameURLCombination = ({ name, url }) => `${name} (${url})`;
+const getNameURLCombination = ({ name, url }: { name: string; url: string }) =>
+  `${name} (${url})`;
 
 /*
 Returns a string of the format:
diff --git a/packages/babel-core/src/tools/build-external-helpers.ts b/packages/babel-core/src/tools/build-external-helpers.ts
index ab7610bb9161..0c9f61e23bc3 100644
--- a/packages/babel-core/src/tools/build-external-helpers.ts
+++ b/packages/babel-core/src/tools/build-external-helpers.ts
@@ -24,10 +24,11 @@ import {
 } from "@babel/types";
 import type * as t from "@babel/types";
 import File from "../transformation/file/file";
+import type { PublicReplacements } from "@babel/template/src/options";
 
 // Wrapped to avoid wasting time parsing this when almost no-one uses
 // build-external-helpers.
-const buildUmdWrapper = replacements =>
+const buildUmdWrapper = (replacements: PublicReplacements) =>
   template.statement`
     (function (root, factory) {
       if (typeof define === "function" && define.amd) {
@@ -145,6 +146,17 @@ function buildVar(allowlist?: Array<string>) {
   return tree;
 }
 
+function buildHelpers(
+  body: t.Statement[],
+  namespace: t.Expression,
+  allowlist?: Array<string>,
+): Record<string, t.MemberExpression>;
+function buildHelpers(
+  body: t.Statement[],
+  namespace: null,
+  allowlist?: Array<string>,
+): Record<string, t.Identifier>;
+
 function buildHelpers(
   body: t.Statement[],
   namespace: t.Expression | null,
@@ -156,7 +168,7 @@ function buildHelpers(
       : identifier(`_${name}`);
   };
 
-  const refs = {};
+  const refs: { [key: string]: t.Identifier | t.MemberExpression } = {};
   helpers.list.forEach(function (name) {
     if (allowlist && allowlist.indexOf(name) < 0) return;
 
diff --git a/packages/babel-core/src/transform-ast.ts b/packages/babel-core/src/transform-ast.ts
index d42dbb79913f..6e16d52b0cb8 100644
--- a/packages/babel-core/src/transform-ast.ts
+++ b/packages/babel-core/src/transform-ast.ts
@@ -37,12 +37,17 @@ const transformFromAstRunner = gensync<
 export const transformFromAst: TransformFromAst = function transformFromAst(
   ast,
   code,
-  opts,
-  callback?,
+  optsOrCallback?: InputOptions | null | undefined | FileResultCallback,
+  maybeCallback?: FileResultCallback,
 ) {
-  if (typeof opts === "function") {
-    callback = opts;
+  let opts: InputOptions | undefined | null;
+  let callback: FileResultCallback | undefined;
+  if (typeof optsOrCallback === "function") {
+    callback = optsOrCallback;
     opts = undefined;
+  } else {
+    opts = optsOrCallback;
+    callback = maybeCallback;
   }
 
   if (callback === undefined) {
diff --git a/packages/babel-core/src/transform-file-browser.ts b/packages/babel-core/src/transform-file-browser.ts
index 1adbcd649b52..f316cb432e7c 100644
--- a/packages/babel-core/src/transform-file-browser.ts
+++ b/packages/babel-core/src/transform-file-browser.ts
@@ -1,13 +1,17 @@
 // duplicated from transform-file so we do not have to import anything here
 type TransformFile = {
-  (filename: string, callback: Function): void;
-  (filename: string, opts: any, callback: Function): void;
+  (filename: string, callback: (error: Error, file: null) => void): void;
+  (
+    filename: string,
+    opts: any,
+    callback: (error: Error, file: null) => void,
+  ): void;
 };
 
 export const transformFile: TransformFile = function transformFile(
   filename,
   opts,
-  callback?,
+  callback?: (error: Error, file: null) => void,
 ) {
   if (typeof opts === "function") {
     callback = opts;
diff --git a/packages/babel-core/src/transform.ts b/packages/babel-core/src/transform.ts
index 668b20de5ab7..310070bc7805 100644
--- a/packages/babel-core/src/transform.ts
+++ b/packages/babel-core/src/transform.ts
@@ -6,6 +6,8 @@ import { run } from "./transformation";
 
 import type { FileResult, FileResultCallback } from "./transformation";
 
+export type { FileResult } from "./transformation";
+
 type Transform = {
   (code: string, callback: FileResultCallback): void;
   (
@@ -25,10 +27,19 @@ const transformRunner = gensync<
   return yield* run(config, code);
 });
 
-export const transform: Transform = function transform(code, opts?, callback?) {
-  if (typeof opts === "function") {
-    callback = opts;
+export const transform: Transform = function transform(
+  code,
+  optsOrCallback?: InputOptions | null | undefined | FileResultCallback,
+  maybeCallback?: FileResultCallback,
+) {
+  let opts: InputOptions | undefined | null;
+  let callback: FileResultCallback | undefined;
+  if (typeof optsOrCallback === "function") {
+    callback = optsOrCallback;
     opts = undefined;
+  } else {
+    opts = optsOrCallback;
+    callback = maybeCallback;
   }
 
   if (callback === undefined) {
diff --git a/packages/babel-core/src/transformation/block-hoist-plugin.ts b/packages/babel-core/src/transformation/block-hoist-plugin.ts
index 445e1866de8d..54b1eef5d31f 100644
--- a/packages/babel-core/src/transformation/block-hoist-plugin.ts
+++ b/packages/babel-core/src/transformation/block-hoist-plugin.ts
@@ -1,4 +1,6 @@
 import traverse from "@babel/traverse";
+import type { Statement } from "@babel/types";
+import type { PluginObject } from "../config";
 import Plugin from "../config/plugin";
 
 let LOADED_PLUGIN: Plugin | void;
@@ -17,14 +19,14 @@ export default function loadBlockHoistPlugin(): Plugin {
 
   return LOADED_PLUGIN;
 }
-function priority(bodyNode) {
+function priority(bodyNode: Statement & { _blockHoist?: number | true }) {
   const priority = bodyNode?._blockHoist;
   if (priority == null) return 1;
   if (priority === true) return 2;
   return priority;
 }
 
-function stableSort(body) {
+function stableSort(body: Statement[]) {
   // By default, we use priorities of 0-4.
   const buckets = Object.create(null);
 
@@ -54,7 +56,7 @@ function stableSort(body) {
   return body;
 }
 
-const blockHoistPlugin = {
+const blockHoistPlugin: PluginObject = {
   /**
    * [Please add a description.]
    *
diff --git a/packages/babel-core/src/transformation/file/file.ts b/packages/babel-core/src/transformation/file/file.ts
index d44b64799941..ad3a5524718c 100644
--- a/packages/babel-core/src/transformation/file/file.ts
+++ b/packages/babel-core/src/transformation/file/file.ts
@@ -1,6 +1,6 @@
 import * as helpers from "@babel/helpers";
 import { NodePath, Scope } from "@babel/traverse";
-import type { HubInterface } from "@babel/traverse";
+import type { HubInterface, Visitor } from "@babel/traverse";
 import { codeFrameColumns } from "@babel/code-frame";
 import traverse from "@babel/traverse";
 import { cloneNode, interpreterDirective } from "@babel/types";
@@ -10,7 +10,7 @@ import semver from "semver";
 
 import type { NormalizedFile } from "../normalize-file";
 
-const errorVisitor = {
+const errorVisitor: Visitor<{ loc: NodeLocation["loc"] | null }> = {
   enter(path, state) {
     const loc = path.node.loc;
     if (loc) {
@@ -44,15 +44,15 @@ export type NodeLocation = {
 };
 
 export default class File {
-  _map: Map<any, any> = new Map();
-  opts: any;
-  declarations: any = {};
-  path: NodePath<t.Program> = null;
-  ast: any = {};
+  _map: Map<unknown, unknown> = new Map();
+  opts: { [key: string]: any };
+  declarations: { [key: string]: t.Identifier } = {};
+  path: NodePath<t.Program>;
+  ast: t.File;
   scope: Scope;
-  metadata: {} = {};
+  metadata: { [key: string]: any } = {};
   code: string = "";
-  inputMap: any | null = null;
+  inputMap: any;
 
   hub: HubInterface & { file: File } = {
     // keep it for the usage in babel-core, ex: path.hub.file.opts.filename
@@ -191,7 +191,7 @@ export default class File {
     const uid = (this.declarations[name] =
       this.scope.generateUidIdentifier(name));
 
-    const dependencies = {};
+    const dependencies: { [key: string]: t.Identifier } = {};
     for (const dep of helpers.getDependencies(name)) {
       dependencies[dep] = this.addHelper(dep);
     }
@@ -239,7 +239,7 @@ export default class File {
     let loc = node && (node.loc || node._loc);
 
     if (!loc && node) {
-      const state = {
+      const state: { loc?: NodeLocation["loc"] | null } = {
         loc: null,
       };
       traverse(node as t.Node, errorVisitor, this.scope, state);
diff --git a/packages/babel-core/src/transformation/index.ts b/packages/babel-core/src/transformation/index.ts
index 4d83285e9735..78d587c8e265 100644
--- a/packages/babel-core/src/transformation/index.ts
+++ b/packages/babel-core/src/transformation/index.ts
@@ -16,17 +16,17 @@ import type File from "./file/file";
 import { flattenToSet } from "../config/helpers/deep-array";
 
 export type FileResultCallback = {
-  (err: Error, file: null): any;
-  (err: null, file: FileResult | null): any;
+  (err: Error, file: null): void;
+  (err: null, file: FileResult | null): void;
 };
 
 export type FileResult = {
-  metadata: {};
-  options: {};
-  ast: {} | null;
+  metadata: { [key: string]: any };
+  options: { [key: string]: any };
+  ast: t.File | null;
   code: string | null;
   map: SourceMap | null;
-  sourceType: "string" | "module";
+  sourceType: "script" | "module";
   externalDependencies: Set<string>;
 };
 
diff --git a/packages/babel-core/src/transformation/normalize-file.ts b/packages/babel-core/src/transformation/normalize-file.ts
index e1e730565068..ce9c0ae2df1e 100644
--- a/packages/babel-core/src/transformation/normalize-file.ts
+++ b/packages/babel-core/src/transformation/normalize-file.ts
@@ -16,13 +16,13 @@ const LARGE_INPUT_SOURCEMAP_THRESHOLD = 3_000_000;
 
 export type NormalizedFile = {
   code: string;
-  ast: {};
+  ast: t.File;
   inputMap: Converter | null;
 };
 
 export default function* normalizeFile(
   pluginPasses: PluginPasses,
-  options: any,
+  options: { [key: string]: any },
   code: string,
   ast?: t.File | t.Program | null,
 ): Handler<File> {
@@ -36,7 +36,7 @@ export default function* normalizeFile(
     }
 
     if (options.cloneInputAst) {
-      ast = cloneDeep(ast);
+      ast = cloneDeep(ast) as t.File;
     }
   } else {
     ast = yield* parser(pluginPasses, options, code);
@@ -105,7 +105,11 @@ const INLINE_SOURCEMAP_REGEX =
 const EXTERNAL_SOURCEMAP_REGEX =
   /^[@#][ \t]+sourceMappingURL=([^\s'"`]+)[ \t]*$/;
 
-function extractCommentsFromList(regex, comments, lastComment) {
+function extractCommentsFromList(
+  regex: RegExp,
+  comments: t.Comment[],
+  lastComment: string | null,
+): [t.Comment[], string | null] {
   if (comments) {
     comments = comments.filter(({ value }) => {
       if (regex.test(value)) {
@@ -118,8 +122,8 @@ function extractCommentsFromList(regex, comments, lastComment) {
   return [comments, lastComment];
 }
 
-function extractComments(regex, ast) {
-  let lastComment = null;
+function extractComments(regex: RegExp, ast: t.Node) {
+  let lastComment: string = null;
   traverseFast(ast, node => {
     [node.leadingComments, lastComment] = extractCommentsFromList(
       regex,
diff --git a/packages/babel-generator/src/buffer.ts b/packages/babel-generator/src/buffer.ts
index 9070b2997187..f097e4fe2070 100644
--- a/packages/babel-generator/src/buffer.ts
+++ b/packages/babel-generator/src/buffer.ts
@@ -1,12 +1,11 @@
 import type SourceMap from "./source-map";
-import type * as t from "@babel/types";
 import * as charcodes from "charcodes";
 
-type Pos = {
+export type Pos = {
   line: number;
   column: number;
 };
-type Loc = {
+export type Loc = {
   start?: Pos;
   end?: Pos;
   identifierName?: string;
@@ -63,14 +62,18 @@ export default class Buffer {
 
       // Encoding the sourcemap is moderately CPU expensive.
       get map() {
-        return (result.map = map ? map.get() : null);
+        const resultMap = map ? map.get() : null;
+        result.map = resultMap;
+        return resultMap;
       },
       set map(value) {
         Object.defineProperty(result, "map", { value, writable: true });
       },
       // Retrieving the raw mappings is very memory intensive.
       get rawMappings() {
-        return (result.rawMappings = map?.getRawMappings());
+        const mappings = map?.getRawMappings();
+        result.rawMappings = mappings;
+        return mappings;
       },
       set rawMappings(value) {
         Object.defineProperty(result, "rawMappings", { value, writable: true });
@@ -241,7 +244,7 @@ export default class Buffer {
    * With this line, there will be one mapping range over "mod" and another
    * over "();", where previously it would have been a single mapping.
    */
-  exactSource(loc: any, cb: () => void) {
+  exactSource(loc: Loc | undefined, cb: () => void) {
     this.source("start", loc);
 
     cb();
@@ -262,7 +265,7 @@ export default class Buffer {
    * will be given this position in the sourcemap.
    */
 
-  source(prop: string, loc: t.SourceLocation): void {
+  source(prop: "start" | "end", loc: Loc | undefined): void {
     if (prop && !loc) return;
 
     // Since this is called extremely often, we re-use the same _sourcePosition
@@ -274,7 +277,7 @@ export default class Buffer {
    * Call a callback with a specific source location and restore on completion.
    */
 
-  withSource(prop: string, loc: t.SourceLocation, cb: () => void): void {
+  withSource(prop: "start" | "end", loc: Loc, cb: () => void): void {
     if (!this._map) return cb();
 
     // Use the call stack to manage a stack of "source location" data because
@@ -309,14 +312,14 @@ export default class Buffer {
    * sourcemap output, so that certain printers can be sure that the
    * "end" location that they set is actually treated as the end position.
    */
-  _disallowPop(prop: string, loc: t.SourceLocation) {
+  _disallowPop(prop: "start" | "end", loc: Loc) {
     if (prop && !loc) return;
 
     this._disallowedPop = this._normalizePosition(prop, loc, SourcePos());
   }
 
   _normalizePosition(
-    prop: string,
+    prop: "start" | "end",
     loc: Loc | undefined | null,
     targetObj: SourcePos,
   ) {
diff --git a/packages/babel-generator/src/generators/base.ts b/packages/babel-generator/src/generators/base.ts
index 30253db2e5f7..ae53b83d0fc1 100644
--- a/packages/babel-generator/src/generators/base.ts
+++ b/packages/babel-generator/src/generators/base.ts
@@ -58,7 +58,7 @@ const unescapedDoubleQuoteRE = /(?:^|[^\\])(?:\\\\)*"/;
 
 export function DirectiveLiteral(this: Printer, node: t.DirectiveLiteral) {
   const raw = this.getPossibleRaw(node);
-  if (!this.format.minified && raw != null) {
+  if (!this.format.minified && raw !== undefined) {
     this.token(raw);
     return;
   }
diff --git a/packages/babel-generator/src/generators/classes.ts b/packages/babel-generator/src/generators/classes.ts
index 77eea7ea2664..0212bd9d4737 100644
--- a/packages/babel-generator/src/generators/classes.ts
+++ b/packages/babel-generator/src/generators/classes.ts
@@ -9,7 +9,7 @@ import * as charCodes from "charcodes";
 export function ClassDeclaration(
   this: Printer,
   node: t.ClassDeclaration,
-  parent: any,
+  parent: t.Node,
 ) {
   if (
     !this.format.decoratorsBeforeExport ||
@@ -86,7 +86,7 @@ export function ClassProperty(this: Printer, node: t.ClassProperty) {
   // between member modifiers and the property key.
   this.source("end", node.key.loc);
 
-  this.tsPrintClassMemberModifiers(node, /* isField */ true);
+  this.tsPrintClassMemberModifiers(node);
 
   if (node.computed) {
     this.token("[");
@@ -125,7 +125,8 @@ export function ClassAccessorProperty(
   // between member modifiers and the property key.
   this.source("end", node.key.loc);
 
-  this.tsPrintClassMemberModifiers(node, /* isField */ true);
+  // TS does not support class accessor property yet
+  this.tsPrintClassMemberModifiers(node);
 
   this.word("accessor");
   this.printInnerComments(node);
@@ -136,6 +137,7 @@ export function ClassAccessorProperty(
     this.print(node.key, node);
     this.token("]");
   } else {
+    // Todo: Flow does not support class accessor property yet.
     this._variance(node);
     this.print(node.key, node);
   }
@@ -190,12 +192,15 @@ export function ClassPrivateMethod(this: Printer, node: t.ClassPrivateMethod) {
   this.print(node.body, node);
 }
 
-export function _classMethodHead(this: Printer, node) {
+export function _classMethodHead(
+  this: Printer,
+  node: t.ClassMethod | t.ClassPrivateMethod | t.TSDeclareMethod,
+) {
   this.printJoin(node.decorators, node);
   // catch up to method key, avoid line break
   // between member modifiers/method heads and the method key.
   this.source("end", node.key.loc);
-  this.tsPrintClassMemberModifiers(node, /* isField */ false);
+  this.tsPrintClassMemberModifiers(node);
   this._methodHead(node);
 }
 
diff --git a/packages/babel-generator/src/generators/expressions.ts b/packages/babel-generator/src/generators/expressions.ts
index 311346cd123c..c79bf17c9ad3 100644
--- a/packages/babel-generator/src/generators/expressions.ts
+++ b/packages/babel-generator/src/generators/expressions.ts
@@ -49,9 +49,7 @@ export function UpdateExpression(this: Printer, node: t.UpdateExpression) {
     this.token(node.operator);
     this.print(node.argument, node);
   } else {
-    this.startTerminatorless(true);
-    this.print(node.argument, node);
-    this.endTerminatorless();
+    this.printTerminatorless(node.argument, node, true);
     this.token(node.operator);
   }
 }
@@ -74,7 +72,7 @@ export function ConditionalExpression(
 export function NewExpression(
   this: Printer,
   node: t.NewExpression,
-  parent: any,
+  parent: t.Node,
 ) {
   this.word("new");
   this.space();
@@ -116,7 +114,7 @@ export function Super(this: Printer) {
 
 function isDecoratorMemberExpression(
   node: t.Expression | t.V8IntrinsicIdentifier,
-) {
+): boolean {
   switch (node.type) {
     case "Identifier":
       return true;
@@ -218,25 +216,27 @@ export function Import(this: Printer) {
   this.word("import");
 }
 
-function buildYieldAwait(keyword: string) {
-  return function (this: Printer, node: any) {
-    this.word(keyword);
-
-    if (node.delegate) {
-      this.token("*");
-    }
+export function AwaitExpression(this: Printer, node: t.AwaitExpression) {
+  this.word("await");
 
-    if (node.argument) {
-      this.space();
-      const terminatorState = this.startTerminatorless();
-      this.print(node.argument, node);
-      this.endTerminatorless(terminatorState);
-    }
-  };
+  if (node.argument) {
+    this.space();
+    this.printTerminatorless(node.argument, node, false);
+  }
 }
 
-export const YieldExpression = buildYieldAwait("yield");
-export const AwaitExpression = buildYieldAwait("await");
+export function YieldExpression(this: Printer, node: t.YieldExpression) {
+  this.word("yield");
+
+  if (node.delegate) {
+    this.token("*");
+  }
+
+  if (node.argument) {
+    this.space();
+    this.printTerminatorless(node.argument, node, false);
+  }
+}
 
 export function EmptyStatement(this: Printer) {
   this.semicolon(true /* force */);
@@ -265,7 +265,7 @@ export function AssignmentPattern(this: Printer, node: t.AssignmentPattern) {
 export function AssignmentExpression(
   this: Printer,
   node: t.AssignmentExpression,
-  parent: any,
+  parent: t.Node,
 ) {
   // Somewhere inside a for statement `init` node but doesn't usually
   // needs a paren except for `in` expressions: `for (a in b ? a : b;;)`
diff --git a/packages/babel-generator/src/generators/flow.ts b/packages/babel-generator/src/generators/flow.ts
index f2ca2a6700c5..2a7af18ac267 100644
--- a/packages/babel-generator/src/generators/flow.ts
+++ b/packages/babel-generator/src/generators/flow.ts
@@ -48,7 +48,7 @@ export function DeclareClass(
 export function DeclareFunction(
   this: Printer,
   node: t.DeclareFunction,
-  parent: any,
+  parent: t.Node,
 ) {
   if (!isDeclareExportDeclaration(parent)) {
     this.word("declare");
@@ -118,7 +118,7 @@ export function DeclareTypeAlias(this: Printer, node: t.DeclareTypeAlias) {
 export function DeclareOpaqueType(
   this: Printer,
   node: t.DeclareOpaqueType,
-  parent: any,
+  parent: t.Node,
 ) {
   if (!isDeclareExportDeclaration(parent)) {
     this.word("declare");
@@ -130,7 +130,7 @@ export function DeclareOpaqueType(
 export function DeclareVariable(
   this: Printer,
   node: t.DeclareVariable,
-  parent: any,
+  parent: t.Node,
 ) {
   if (!isDeclareExportDeclaration(parent)) {
     this.word("declare");
@@ -174,7 +174,7 @@ export function EnumDeclaration(this: Printer, node: t.EnumDeclaration) {
 }
 
 function enumExplicitType(
-  context: any,
+  context: Printer,
   name: string,
   hasExplicitType: boolean,
 ) {
@@ -187,7 +187,7 @@ function enumExplicitType(
   context.space();
 }
 
-function enumBody(context: any, node: any) {
+function enumBody(context: Printer, node: t.EnumBody) {
   const { members } = node;
   context.token("{");
   context.indent();
@@ -236,7 +236,10 @@ export function EnumDefaultedMember(
   this.token(",");
 }
 
-function enumInitializedMember(context: any, node: any) {
+function enumInitializedMember(
+  context: Printer,
+  node: t.EnumBooleanMember | t.EnumNumberMember | t.EnumStringMember,
+) {
   const { id, init } = node;
   context.print(id, node);
   context.space();
@@ -258,7 +261,10 @@ export function EnumStringMember(this: Printer, node: t.EnumStringMember) {
   enumInitializedMember(this, node);
 }
 
-function FlowExportDeclaration(this: Printer, node: any) {
+function FlowExportDeclaration(
+  this: Printer,
+  node: t.DeclareExportDeclaration,
+) {
   if (node.declaration) {
     const declar = node.declaration;
     this.print(declar, node);
@@ -384,7 +390,16 @@ export function _interfaceish(
   this.print(node.body, node);
 }
 
-export function _variance(this: Printer, node) {
+export function _variance(
+  this: Printer,
+  node:
+    | t.TypeParameter
+    | t.ObjectTypeIndexer
+    | t.ObjectTypeProperty
+    | t.ClassProperty
+    | t.ClassPrivateProperty
+    | t.ClassAccessorProperty,
+) {
   if (node.variance) {
     if (node.variance.kind === "plus") {
       this.token("+");
diff --git a/packages/babel-generator/src/generators/jsx.ts b/packages/babel-generator/src/generators/jsx.ts
index fb3fd8356b85..3919626f08cf 100644
--- a/packages/babel-generator/src/generators/jsx.ts
+++ b/packages/babel-generator/src/generators/jsx.ts
@@ -54,7 +54,7 @@ export function JSXSpreadChild(this: Printer, node: t.JSXSpreadChild) {
 export function JSXText(this: Printer, node: t.JSXText) {
   const raw = this.getPossibleRaw(node);
 
-  if (raw != null) {
+  if (raw !== undefined) {
     this.token(raw);
   } else {
     this.token(node.value);
diff --git a/packages/babel-generator/src/generators/methods.ts b/packages/babel-generator/src/generators/methods.ts
index 42c6d3d5b20f..d86c676bdf3b 100644
--- a/packages/babel-generator/src/generators/methods.ts
+++ b/packages/babel-generator/src/generators/methods.ts
@@ -2,7 +2,10 @@ import type Printer from "../printer";
 import { isIdentifier } from "@babel/types";
 import type * as t from "@babel/types";
 
-export function _params(this: Printer, node: any) {
+export function _params(
+  this: Printer,
+  node: t.Function | t.TSDeclareMethod | t.TSDeclareFunction,
+) {
   this.print(node.typeParameters, node);
   this.token("(");
   this._parameters(node.params, node);
@@ -11,7 +14,17 @@ export function _params(this: Printer, node: any) {
   this.print(node.returnType, node);
 }
 
-export function _parameters(this: Printer, parameters, parent) {
+export function _parameters(
+  this: Printer,
+  parameters: t.Function["params"],
+  parent:
+    | t.Function
+    | t.TSIndexSignature
+    | t.TSDeclareMethod
+    | t.TSDeclareFunction
+    | t.TSFunctionType
+    | t.TSConstructorType,
+) {
   for (let i = 0; i < parameters.length; i++) {
     this._param(parameters[i], parent);
 
@@ -22,14 +35,34 @@ export function _parameters(this: Printer, parameters, parent) {
   }
 }
 
-export function _param(this: Printer, parameter, parent?) {
+export function _param(
+  this: Printer,
+  parameter: t.Identifier | t.RestElement | t.Pattern | t.TSParameterProperty,
+  parent?:
+    | t.Function
+    | t.TSIndexSignature
+    | t.TSDeclareMethod
+    | t.TSDeclareFunction
+    | t.TSFunctionType
+    | t.TSConstructorType,
+) {
   this.printJoin(parameter.decorators, parameter);
   this.print(parameter, parent);
-  if (parameter.optional) this.token("?"); // TS / flow
-  this.print(parameter.typeAnnotation, parameter); // TS / flow
+  if (
+    // @ts-expect-error optional is not in TSParameterProperty
+    parameter.optional
+  ) {
+    this.token("?"); // TS / flow
+  }
+
+  this.print(
+    // @ts-expect-error typeAnnotation is not in TSParameterProperty
+    parameter.typeAnnotation,
+    parameter,
+  ); // TS / flow
 }
 
-export function _methodHead(this: Printer, node: any) {
+export function _methodHead(this: Printer, node: t.Method | t.TSDeclareMethod) {
   const kind = node.kind;
   const key = node.key;
 
@@ -45,7 +78,11 @@ export function _methodHead(this: Printer, node: any) {
     this.space();
   }
 
-  if (kind === "method" || kind === "init") {
+  if (
+    kind === "method" ||
+    // @ts-ignore Fixme: kind: "init" is not defined
+    kind === "init"
+  ) {
     if (node.generator) {
       this.token("*");
     }
@@ -59,7 +96,10 @@ export function _methodHead(this: Printer, node: any) {
     this.print(key, node);
   }
 
-  if (node.optional) {
+  if (
+    // @ts-expect-error optional is not in ObjectMethod
+    node.optional
+  ) {
     // TS
     this.token("?");
   }
@@ -67,7 +107,13 @@ export function _methodHead(this: Printer, node: any) {
   this._params(node);
 }
 
-export function _predicate(this: Printer, node: any) {
+export function _predicate(
+  this: Printer,
+  node:
+    | t.FunctionDeclaration
+    | t.FunctionExpression
+    | t.ArrowFunctionExpression,
+) {
   if (node.predicate) {
     if (!node.returnType) {
       this.token(":");
@@ -77,7 +123,10 @@ export function _predicate(this: Printer, node: any) {
   }
 }
 
-export function _functionHead(this: Printer, node: any) {
+export function _functionHead(
+  this: Printer,
+  node: t.FunctionDeclaration | t.FunctionExpression | t.TSDeclareFunction,
+) {
   if (node.async) {
     this.word("async");
     this.space();
@@ -92,7 +141,9 @@ export function _functionHead(this: Printer, node: any) {
   }
 
   this._params(node);
-  this._predicate(node);
+  if (node.type !== "TSDeclareFunction") {
+    this._predicate(node);
+  }
 }
 
 export function FunctionExpression(this: Printer, node: t.FunctionExpression) {
diff --git a/packages/babel-generator/src/generators/modules.ts b/packages/babel-generator/src/generators/modules.ts
index aeaec676f2ba..ccd6c382d6cf 100644
--- a/packages/babel-generator/src/generators/modules.ts
+++ b/packages/babel-generator/src/generators/modules.ts
@@ -98,28 +98,6 @@ export function ExportNamedDeclaration(
 
   this.word("export");
   this.space();
-  ExportDeclaration.apply(this, arguments);
-}
-
-export function ExportDefaultDeclaration(
-  this: Printer,
-  node: t.ExportDefaultDeclaration,
-) {
-  if (
-    this.format.decoratorsBeforeExport &&
-    isClassDeclaration(node.declaration)
-  ) {
-    this.printJoin(node.declaration.decorators, node);
-  }
-
-  this.word("export");
-  this.space();
-  this.word("default");
-  this.space();
-  ExportDeclaration.apply(this, arguments);
-}
-
-function ExportDeclaration(this: Printer, node: any) {
   if (node.declaration) {
     const declar = node.declaration;
     this.print(declar, node);
@@ -173,6 +151,26 @@ function ExportDeclaration(this: Printer, node: any) {
   }
 }
 
+export function ExportDefaultDeclaration(
+  this: Printer,
+  node: t.ExportDefaultDeclaration,
+) {
+  if (
+    this.format.decoratorsBeforeExport &&
+    isClassDeclaration(node.declaration)
+  ) {
+    this.printJoin(node.declaration.decorators, node);
+  }
+
+  this.word("export");
+  this.space();
+  this.word("default");
+  this.space();
+  const declar = node.declaration;
+  this.print(declar, node);
+  if (!isStatement(declar)) this.semicolon();
+}
+
 export function ImportDeclaration(this: Printer, node: t.ImportDeclaration) {
   this.word("import");
   this.space();
diff --git a/packages/babel-generator/src/generators/statements.ts b/packages/babel-generator/src/generators/statements.ts
index 52b1eea6bf19..aa0fad48867e 100644
--- a/packages/babel-generator/src/generators/statements.ts
+++ b/packages/babel-generator/src/generators/statements.ts
@@ -50,9 +50,14 @@ export function IfStatement(this: Printer, node: t.IfStatement) {
 }
 
 // Recursively get the last statement.
-function getLastStatement(statement) {
-  if (!isStatement(statement.body)) return statement;
-  return getLastStatement(statement.body);
+function getLastStatement(statement: t.Statement): t.Statement {
+  // @ts-ignore: If statement.body is empty or not a Node, isStatement will return false
+  const { body } = statement;
+  if (isStatement(body) === false) {
+    return statement;
+  }
+
+  return getLastStatement(body);
 }
 
 export function ForStatement(this: Printer, node: t.ForStatement) {
@@ -89,27 +94,26 @@ export function WhileStatement(this: Printer, node: t.WhileStatement) {
   this.printBlock(node);
 }
 
-const buildForXStatement = function (op) {
-  return function (this: Printer, node: any) {
-    this.word("for");
-    this.space();
-    if (op === "of" && node.await) {
-      this.word("await");
-      this.space();
-    }
-    this.token("(");
-    this.print(node.left, node);
-    this.space();
-    this.word(op);
+function ForXStatement(this: Printer, node: t.ForXStatement) {
+  this.word("for");
+  this.space();
+  const isForOf = node.type === "ForOfStatement";
+  if (isForOf && node.await) {
+    this.word("await");
     this.space();
-    this.print(node.right, node);
-    this.token(")");
-    this.printBlock(node);
-  };
-};
+  }
+  this.token("(");
+  this.print(node.left, node);
+  this.space();
+  this.word(isForOf ? "of" : "in");
+  this.space();
+  this.print(node.right, node);
+  this.token(")");
+  this.printBlock(node);
+}
 
-export const ForInStatement = buildForXStatement("in");
-export const ForOfStatement = buildForXStatement("of");
+export const ForInStatement = ForXStatement;
+export const ForOfStatement = ForXStatement;
 
 export function DoWhileStatement(this: Printer, node: t.DoWhileStatement) {
   this.word("do");
@@ -124,27 +128,39 @@ export function DoWhileStatement(this: Printer, node: t.DoWhileStatement) {
   this.semicolon();
 }
 
-function buildLabelStatement(prefix, key = "label") {
-  return function (this: Printer, node: any) {
-    this.word(prefix);
-
-    const label = node[key];
-    if (label) {
-      this.space();
-      const isLabel = key == "label";
-      const terminatorState = this.startTerminatorless(isLabel);
-      this.print(label, node);
-      this.endTerminatorless(terminatorState);
-    }
+function printStatementAfterKeyword(
+  printer: Printer,
+  node: t.Node,
+  parent: t.Node,
+  isLabel: boolean,
+) {
+  if (node) {
+    printer.space();
+    printer.printTerminatorless(node, parent, isLabel);
+  }
 
-    this.semicolon();
-  };
+  printer.semicolon();
 }
 
-export const ContinueStatement = buildLabelStatement("continue");
-export const ReturnStatement = buildLabelStatement("return", "argument");
-export const BreakStatement = buildLabelStatement("break");
-export const ThrowStatement = buildLabelStatement("throw", "argument");
+export function BreakStatement(this: Printer, node: t.ContinueStatement) {
+  this.word("break");
+  printStatementAfterKeyword(this, node.label, node, true);
+}
+
+export function ContinueStatement(this: Printer, node: t.ContinueStatement) {
+  this.word("continue");
+  printStatementAfterKeyword(this, node.label, node, true);
+}
+
+export function ReturnStatement(this: Printer, node: t.ReturnStatement) {
+  this.word("return");
+  printStatementAfterKeyword(this, node.argument, node, false);
+}
+
+export function ThrowStatement(this: Printer, node: t.ThrowStatement) {
+  this.word("throw");
+  printStatementAfterKeyword(this, node.argument, node, false);
+}
 
 export function LabeledStatement(this: Printer, node: t.LabeledStatement) {
   this.print(node.label, node);
diff --git a/packages/babel-generator/src/generators/template-literals.ts b/packages/babel-generator/src/generators/template-literals.ts
index 14e5a4e03b7f..48c9e5589ebb 100644
--- a/packages/babel-generator/src/generators/template-literals.ts
+++ b/packages/babel-generator/src/generators/template-literals.ts
@@ -13,7 +13,7 @@ export function TaggedTemplateExpression(
 export function TemplateElement(
   this: Printer,
   node: t.TemplateElement,
-  parent: any,
+  parent: t.TemplateLiteral,
 ) {
   const isFirst = parent.quasis[0] === node;
   const isLast = parent.quasis[parent.quasis.length - 1] === node;
diff --git a/packages/babel-generator/src/generators/types.ts b/packages/babel-generator/src/generators/types.ts
index 779df2d69f8c..552b81faade6 100644
--- a/packages/babel-generator/src/generators/types.ts
+++ b/packages/babel-generator/src/generators/types.ts
@@ -201,7 +201,7 @@ export function NumericLiteral(this: Printer, node: t.NumericLiteral) {
 
 export function StringLiteral(this: Printer, node: t.StringLiteral) {
   const raw = this.getPossibleRaw(node);
-  if (!this.format.minified && raw != null) {
+  if (!this.format.minified && raw !== undefined) {
     this.token(raw);
     return;
   }
@@ -221,7 +221,7 @@ export function StringLiteral(this: Printer, node: t.StringLiteral) {
 
 export function BigIntLiteral(this: Printer, node: t.BigIntLiteral) {
   const raw = this.getPossibleRaw(node);
-  if (!this.format.minified && raw != null) {
+  if (!this.format.minified && raw !== undefined) {
     this.word(raw);
     return;
   }
@@ -230,7 +230,7 @@ export function BigIntLiteral(this: Printer, node: t.BigIntLiteral) {
 
 export function DecimalLiteral(this: Printer, node: t.DecimalLiteral) {
   const raw = this.getPossibleRaw(node);
-  if (!this.format.minified && raw != null) {
+  if (!this.format.minified && raw !== undefined) {
     this.word(raw);
     return;
   }
diff --git a/packages/babel-generator/src/generators/typescript.ts b/packages/babel-generator/src/generators/typescript.ts
index 4aa982e8741d..0ffce6004dd3 100644
--- a/packages/babel-generator/src/generators/typescript.ts
+++ b/packages/babel-generator/src/generators/typescript.ts
@@ -131,7 +131,10 @@ export function TSPropertySignature(
   this.token(";");
 }
 
-export function tsPrintPropertyOrMethodName(this: Printer, node) {
+export function tsPrintPropertyOrMethodName(
+  this: Printer,
+  node: t.TSPropertySignature | t.TSMethodSignature,
+) {
   if (node.computed) {
     this.token("[");
   }
@@ -232,13 +235,14 @@ export function TSConstructorType(this: Printer, node: t.TSConstructorType) {
 
 export function tsPrintFunctionOrConstructorType(
   this: Printer,
-  // todo: missing type FunctionOrConstructorType
-  node: any,
+  node: t.TSFunctionType | t.TSConstructorType,
 ) {
   const { typeParameters } = node;
   const parameters = process.env.BABEL_8_BREAKING
-    ? node.params
-    : node.parameters;
+    ? // @ts-ignore Babel 8 AST shape
+      node.params
+    : // @ts-ignore Babel 7 AST shape
+      node.parameters;
   this.print(typeParameters, node);
   this.token("(");
   this._parameters(parameters, node);
@@ -247,8 +251,10 @@ export function tsPrintFunctionOrConstructorType(
   this.token("=>");
   this.space();
   const returnType = process.env.BABEL_8_BREAKING
-    ? node.returnType
-    : node.typeAnnotation;
+    ? // @ts-ignore Babel 8 AST shape
+      node.returnType
+    : // @ts-ignore Babel 7 AST shape
+      node.typeAnnotation;
   this.print(returnType.typeAnnotation, node);
 }
 
@@ -287,26 +293,26 @@ export function TSTypeLiteral(this: Printer, node: t.TSTypeLiteral) {
 
 export function tsPrintTypeLiteralOrInterfaceBody(
   this: Printer,
-  members,
-  node,
+  members: t.TSTypeElement[],
+  node: t.TSType | t.TSInterfaceBody,
 ) {
-  this.tsPrintBraced(members, node);
+  tsPrintBraced(this, members, node);
 }
 
-export function tsPrintBraced(this: Printer, members, node) {
-  this.token("{");
+function tsPrintBraced(printer: Printer, members: t.Node[], node: t.Node) {
+  printer.token("{");
   if (members.length) {
-    this.indent();
-    this.newline();
+    printer.indent();
+    printer.newline();
     for (const member of members) {
-      this.print(member, node);
+      printer.print(member, node);
       //this.token(sep);
-      this.newline();
+      printer.newline();
     }
-    this.dedent();
-    this.rightBrace();
+    printer.dedent();
+    printer.rightBrace();
   } else {
-    this.token("}");
+    printer.token("}");
   }
 }
 
@@ -340,15 +346,19 @@ export function TSNamedTupleMember(this: Printer, node: t.TSNamedTupleMember) {
 }
 
 export function TSUnionType(this: Printer, node: t.TSUnionType) {
-  this.tsPrintUnionOrIntersectionType(node, "|");
+  tsPrintUnionOrIntersectionType(this, node, "|");
 }
 
 export function TSIntersectionType(this: Printer, node: t.TSIntersectionType) {
-  this.tsPrintUnionOrIntersectionType(node, "&");
+  tsPrintUnionOrIntersectionType(this, node, "&");
 }
 
-export function tsPrintUnionOrIntersectionType(this: Printer, node: any, sep) {
-  this.printJoin(node.types, node, {
+function tsPrintUnionOrIntersectionType(
+  printer: Printer,
+  node: t.TSUnionType | t.TSIntersectionType,
+  sep: "|" | "&",
+) {
+  printer.printJoin(node.types, node, {
     separator() {
       this.space();
       this.token(sep);
@@ -445,7 +455,7 @@ export function TSMappedType(this: Printer, node: t.TSMappedType) {
   this.token("}");
 }
 
-function tokenIfPlusMinus(self, tok) {
+function tokenIfPlusMinus(self: Printer, tok: true | "+" | "-") {
   if (tok !== true) {
     self.token(tok);
   }
@@ -550,7 +560,7 @@ export function TSEnumDeclaration(this: Printer, node: t.TSEnumDeclaration) {
   this.space();
   this.print(id, node);
   this.space();
-  this.tsPrintBraced(members, node);
+  tsPrintBraced(this, members, node);
 }
 
 export function TSEnumMember(this: Printer, node: t.TSEnumMember) {
@@ -599,7 +609,7 @@ export function TSModuleDeclaration(
 }
 
 export function TSModuleBlock(this: Printer, node: t.TSModuleBlock) {
-  this.tsPrintBraced(node.body, node);
+  tsPrintBraced(this, node.body, node);
 }
 
 export function TSImportType(this: Printer, node: t.TSImportType) {
@@ -690,7 +700,17 @@ export function tsPrintSignatureDeclarationBase(this: Printer, node: any) {
   this.print(returnType, node);
 }
 
-export function tsPrintClassMemberModifiers(this: Printer, node: any, isField) {
+export function tsPrintClassMemberModifiers(
+  this: Printer,
+  node:
+    | t.ClassProperty
+    | t.ClassAccessorProperty
+    | t.ClassMethod
+    | t.ClassPrivateMethod
+    | t.TSDeclareMethod,
+) {
+  const isField =
+    node.type === "ClassAccessorProperty" || node.type === "ClassProperty";
   if (isField && node.declare) {
     this.word("declare");
     this.space();
diff --git a/packages/babel-generator/src/index.ts b/packages/babel-generator/src/index.ts
index 67d299411bff..c6f609c7e831 100644
--- a/packages/babel-generator/src/index.ts
+++ b/packages/babel-generator/src/index.ts
@@ -3,6 +3,10 @@ import Printer from "./printer";
 import type * as t from "@babel/types";
 import type { Opts as jsescOptions } from "jsesc";
 import type { Format } from "./printer";
+import type {
+  RecordAndTuplePluginOptions,
+  PipelineOperatorPluginOptions,
+} from "@babel/parser";
 import type { DecodedSourceMap, Mapping } from "@jridgewell/gen-mapping";
 
 /**
@@ -13,12 +17,8 @@ import type { DecodedSourceMap, Mapping } from "@jridgewell/gen-mapping";
 class Generator extends Printer {
   constructor(
     ast: t.Node,
-    opts: {
-      sourceFileName?: string;
-      sourceMaps?: boolean;
-      sourceRoot?: string;
-    } = {},
-    code,
+    opts: GeneratorOptions = {},
+    code: string | { [filename: string]: string },
   ) {
     const format = normalizeOptions(code, opts);
     const map = opts.sourceMaps ? new SourceMap(opts, code) : null;
@@ -47,7 +47,10 @@ class Generator extends Printer {
  * - If `opts.compact = "auto"` and the code is over 500KB, `compact` will be set to `true`.
  */
 
-function normalizeOptions(code, opts): Format {
+function normalizeOptions(
+  code: string | { [filename: string]: string },
+  opts: GeneratorOptions,
+): Format {
   const format: Format = {
     auxiliaryCommentBefore: opts.auxiliaryCommentBefore,
     auxiliaryCommentAfter: opts.auxiliaryCommentAfter,
@@ -183,6 +186,7 @@ export interface GeneratorOptions {
 
   /**
    * Set to true to run jsesc with "json": true to print "\u00A9" vs. "©";
+   * @deprecated use `jsescOptions: { json: true }` instead
    */
   jsonCompatibleStrings?: boolean;
 
@@ -200,24 +204,24 @@ export interface GeneratorOptions {
   /**
    * For use with the recordAndTuple token.
    */
-  recordAndTupleSyntaxType?: "hash" | "bar";
+  recordAndTupleSyntaxType?: RecordAndTuplePluginOptions["syntaxType"];
   /**
    * For use with the Hack-style pipe operator.
    * Changes what token is used for pipe bodies’ topic references.
    */
-  topicToken?: "^^" | "@@" | "^" | "%" | "#";
+  topicToken?: PipelineOperatorPluginOptions["topicToken"];
 }
 
 export interface GeneratorResult {
   code: string;
   map: {
     version: number;
-    sources: string[];
-    names: string[];
+    sources: readonly string[];
+    names: readonly string[];
     sourceRoot?: string;
-    sourcesContent?: string[];
+    sourcesContent?: readonly string[];
     mappings: string;
-    file: string;
+    file?: string;
   } | null;
   decodedMap: DecodedSourceMap | undefined;
   rawMappings: Mapping[] | undefined;
diff --git a/packages/babel-generator/src/node/index.ts b/packages/babel-generator/src/node/index.ts
index e6b7184f6dc4..09e2bbdc79cd 100644
--- a/packages/babel-generator/src/node/index.ts
+++ b/packages/babel-generator/src/node/index.ts
@@ -7,11 +7,28 @@ import {
   isMemberExpression,
   isNewExpression,
 } from "@babel/types";
-
-function expandAliases(obj) {
-  const newObj = {};
-
-  function add(type, func) {
+import type * as t from "@babel/types";
+import type { WhitespaceObject } from "./whitespace";
+
+export type NodeHandlers<R> = {
+  [K in string]?: (
+    node: K extends t.Node["type"] ? Extract<t.Node, { type: K }> : t.Node,
+    // todo:
+    // node: K extends keyof typeof t
+    //   ? Extract<typeof t[K], { type: "string" }>
+    //   : t.Node,
+    parent: t.Node,
+    stack: t.Node[],
+  ) => R;
+};
+
+function expandAliases<R>(obj: NodeHandlers<R>) {
+  const newObj: NodeHandlers<R> = {};
+
+  function add(
+    type: string,
+    func: (node: t.Node, parent: t.Node, stack: t.Node[]) => R,
+  ) {
     const fn = newObj[type];
     newObj[type] = fn
       ? function (node, parent, stack) {
@@ -42,12 +59,17 @@ const expandedParens = expandAliases(parens);
 const expandedWhitespaceNodes = expandAliases(whitespace.nodes);
 const expandedWhitespaceList = expandAliases(whitespace.list);
 
-function find(obj, node, parent, printStack?) {
+function find<R>(
+  obj: NodeHandlers<R>,
+  node: t.Node,
+  parent: t.Node,
+  printStack?: t.Node[],
+): R | null {
   const fn = obj[node.type];
   return fn ? fn(node, parent, printStack) : null;
 }
 
-function isOrHasCallExpression(node) {
+function isOrHasCallExpression(node: t.Node): boolean {
   if (isCallExpression(node)) {
     return true;
   }
@@ -55,14 +77,22 @@ function isOrHasCallExpression(node) {
   return isMemberExpression(node) && isOrHasCallExpression(node.object);
 }
 
-export function needsWhitespace(node, parent, type) {
-  if (!node) return 0;
+export function needsWhitespace(
+  node: t.Node,
+  parent: t.Node,
+  type: "before" | "after",
+): boolean {
+  if (!node) return false;
 
   if (isExpressionStatement(node)) {
     node = node.expression;
   }
 
-  let linesInfo = find(expandedWhitespaceNodes, node, parent);
+  let linesInfo: WhitespaceObject | null | boolean = find(
+    expandedWhitespaceNodes,
+    node,
+    parent,
+  );
 
   if (!linesInfo) {
     const items = find(expandedWhitespaceList, node, parent);
@@ -75,21 +105,25 @@ export function needsWhitespace(node, parent, type) {
   }
 
   if (typeof linesInfo === "object" && linesInfo !== null) {
-    return linesInfo[type] || 0;
+    return linesInfo[type] || false;
   }
 
-  return 0;
+  return false;
 }
 
-export function needsWhitespaceBefore(node, parent) {
+export function needsWhitespaceBefore(node: t.Node, parent: t.Node) {
   return needsWhitespace(node, parent, "before");
 }
 
-export function needsWhitespaceAfter(node, parent) {
+export function needsWhitespaceAfter(node: t.Node, parent: t.Node) {
   return needsWhitespace(node, parent, "after");
 }
 
-export function needsParens(node, parent, printStack?) {
+export function needsParens(
+  node: t.Node,
+  parent: t.Node,
+  printStack?: t.Node[],
+) {
   if (!parent) return false;
 
   if (isNewExpression(parent) && parent.callee === node) {
diff --git a/packages/babel-generator/src/node/parentheses.ts b/packages/babel-generator/src/node/parentheses.ts
index df255d85c61a..89ad23b18479 100644
--- a/packages/babel-generator/src/node/parentheses.ts
+++ b/packages/babel-generator/src/node/parentheses.ts
@@ -7,7 +7,7 @@ import {
   isBinaryExpression,
   isUpdateExpression,
   isCallExpression,
-  isClassDeclaration,
+  isClass,
   isClassExpression,
   isConditional,
   isConditionalExpression,
@@ -54,6 +54,7 @@ import type * as t from "@babel/types";
 const PRECEDENCE = {
   "||": 0,
   "??": 0,
+  "|>": 0,
   "&&": 1,
   "|": 2,
   "^": 3,
@@ -79,11 +80,12 @@ const PRECEDENCE = {
   "**": 10,
 };
 
-const isClassExtendsClause = (node: any, parent: any): boolean =>
-  (isClassDeclaration(parent) || isClassExpression(parent)) &&
-  parent.superClass === node;
+const isClassExtendsClause = (
+  node: t.Node,
+  parent: t.Node,
+): parent is t.Class => isClass(parent, { superClass: node });
 
-const hasPostfixPart = (node: any, parent: any) =>
+const hasPostfixPart = (node: t.Node, parent: t.Node) =>
   ((isMemberExpression(parent) || isOptionalMemberExpression(parent)) &&
     parent.object === node) ||
   ((isCallExpression(parent) ||
@@ -93,14 +95,17 @@ const hasPostfixPart = (node: any, parent: any) =>
   (isTaggedTemplateExpression(parent) && parent.tag === node) ||
   isTSNonNullExpression(parent);
 
-export function NullableTypeAnnotation(node: any, parent: any): boolean {
+export function NullableTypeAnnotation(
+  node: t.NullableTypeAnnotation,
+  parent: t.Node,
+): boolean {
   return isArrayTypeAnnotation(parent);
 }
 
 export function FunctionTypeAnnotation(
-  node: any,
-  parent: any,
-  printStack: Array<any>,
+  node: t.FunctionTypeAnnotation,
+  parent: t.Node,
+  printStack: Array<t.Node>,
 ): boolean {
   return (
     // (() => A) | (() => B)
@@ -116,14 +121,17 @@ export function FunctionTypeAnnotation(
   );
 }
 
-export function UpdateExpression(node: any, parent: any): boolean {
+export function UpdateExpression(
+  node: t.UpdateExpression,
+  parent: t.Node,
+): boolean {
   return hasPostfixPart(node, parent) || isClassExtendsClause(node, parent);
 }
 
 export function ObjectExpression(
-  node: any,
-  parent: any,
-  printStack: Array<any>,
+  node: t.ObjectExpression,
+  parent: t.Node,
+  printStack: Array<t.Node>,
 ): boolean {
   return isFirstInContext(printStack, {
     expressionStatement: true,
@@ -132,9 +140,9 @@ export function ObjectExpression(
 }
 
 export function DoExpression(
-  node: any,
-  parent: any,
-  printStack: Array<any>,
+  node: t.DoExpression,
+  parent: t.Node,
+  printStack: Array<t.Node>,
 ): boolean {
   // `async do` can start an expression statement
   return (
@@ -142,7 +150,7 @@ export function DoExpression(
   );
 }
 
-export function Binary(node: any, parent: any): boolean {
+export function Binary(node: t.BinaryExpression, parent: t.Node): boolean {
   if (
     node.operator === "**" &&
     isBinaryExpression(parent, { operator: "**" })
@@ -181,7 +189,10 @@ export function Binary(node: any, parent: any): boolean {
   }
 }
 
-export function UnionTypeAnnotation(node: any, parent: any): boolean {
+export function UnionTypeAnnotation(
+  node: t.UnionTypeAnnotation,
+  parent: t.Node,
+): boolean {
   return (
     isArrayTypeAnnotation(parent) ||
     isNullableTypeAnnotation(parent) ||
@@ -192,7 +203,10 @@ export function UnionTypeAnnotation(node: any, parent: any): boolean {
 
 export { UnionTypeAnnotation as IntersectionTypeAnnotation };
 
-export function OptionalIndexedAccessType(node: any, parent: any): boolean {
+export function OptionalIndexedAccessType(
+  node: t.OptionalIndexedAccessType,
+  parent: t.Node,
+): boolean {
   return isIndexedAccessType(parent, { objectType: node });
 }
 
@@ -204,7 +218,7 @@ export function TSTypeAssertion() {
   return true;
 }
 
-export function TSUnionType(node: any, parent: any): boolean {
+export function TSUnionType(node: t.TSUnionType, parent: t.Node): boolean {
   return (
     isTSArrayType(parent) ||
     isTSOptionalType(parent) ||
@@ -216,7 +230,7 @@ export function TSUnionType(node: any, parent: any): boolean {
 
 export { TSUnionType as TSIntersectionType };
 
-export function TSInferType(node: any, parent: any): boolean {
+export function TSInferType(node: t.TSInferType, parent: t.Node): boolean {
   return isTSArrayType(parent) || isTSOptionalType(parent);
 }
 
@@ -233,7 +247,10 @@ export function TSInstantiationExpression(
   );
 }
 
-export function BinaryExpression(node: any, parent: any): boolean {
+export function BinaryExpression(
+  node: t.BinaryExpression,
+  parent: t.Node,
+): boolean {
   // let i = (1 in []);
   // for ((1 in []);;);
   return (
@@ -241,7 +258,10 @@ export function BinaryExpression(node: any, parent: any): boolean {
   );
 }
 
-export function SequenceExpression(node: any, parent: any): boolean {
+export function SequenceExpression(
+  node: t.SequenceExpression,
+  parent: t.Node,
+): boolean {
   if (
     // Although parentheses wouldn"t hurt around sequence
     // expressions in the head of for loops, traditional style
@@ -264,7 +284,10 @@ export function SequenceExpression(node: any, parent: any): boolean {
   return true;
 }
 
-export function YieldExpression(node: any, parent: any): boolean {
+export function YieldExpression(
+  node: t.YieldExpression,
+  parent: t.Node,
+): boolean {
   return (
     isBinary(parent) ||
     isUnaryLike(parent) ||
@@ -278,9 +301,9 @@ export function YieldExpression(node: any, parent: any): boolean {
 export { YieldExpression as AwaitExpression };
 
 export function ClassExpression(
-  node: any,
-  parent: any,
-  printStack: Array<any>,
+  node: t.ClassExpression,
+  parent: t.Node,
+  printStack: Array<t.Node>,
 ): boolean {
   return isFirstInContext(printStack, {
     expressionStatement: true,
@@ -288,7 +311,14 @@ export function ClassExpression(
   });
 }
 
-export function UnaryLike(node: any, parent: any): boolean {
+export function UnaryLike(
+  node:
+    | t.UnaryLike
+    | t.ArrowFunctionExpression
+    | t.ConditionalExpression
+    | t.AssignmentExpression,
+  parent: t.Node,
+): boolean {
   return (
     hasPostfixPart(node, parent) ||
     isBinaryExpression(parent, { operator: "**", left: node }) ||
@@ -297,9 +327,9 @@ export function UnaryLike(node: any, parent: any): boolean {
 }
 
 export function FunctionExpression(
-  node: any,
-  parent: any,
-  printStack: Array<any>,
+  node: t.FunctionExpression,
+  parent: t.Node,
+  printStack: Array<t.Node>,
 ): boolean {
   return isFirstInContext(printStack, {
     expressionStatement: true,
@@ -307,11 +337,20 @@ export function FunctionExpression(
   });
 }
 
-export function ArrowFunctionExpression(node: any, parent: any): boolean {
+export function ArrowFunctionExpression(
+  node: t.ArrowFunctionExpression,
+  parent: t.Node,
+): boolean {
   return isExportDeclaration(parent) || ConditionalExpression(node, parent);
 }
 
-export function ConditionalExpression(node: any, parent?): boolean {
+export function ConditionalExpression(
+  node:
+    | t.ConditionalExpression
+    | t.ArrowFunctionExpression
+    | t.AssignmentExpression,
+  parent?: t.Node,
+): boolean {
   if (
     isUnaryLike(parent) ||
     isBinary(parent) ||
@@ -326,7 +365,10 @@ export function ConditionalExpression(node: any, parent?): boolean {
   return UnaryLike(node, parent);
 }
 
-export function OptionalMemberExpression(node: any, parent: any): boolean {
+export function OptionalMemberExpression(
+  node: t.OptionalMemberExpression,
+  parent: t.Node,
+): boolean {
   return (
     isCallExpression(parent, { callee: node }) ||
     isMemberExpression(parent, { object: node })
@@ -335,7 +377,10 @@ export function OptionalMemberExpression(node: any, parent: any): boolean {
 
 export { OptionalMemberExpression as OptionalCallExpression };
 
-export function AssignmentExpression(node: any, parent: any): boolean {
+export function AssignmentExpression(
+  node: t.AssignmentExpression,
+  parent: t.Node,
+): boolean {
   if (isObjectPattern(node.left)) {
     return true;
   } else {
@@ -343,7 +388,10 @@ export function AssignmentExpression(node: any, parent: any): boolean {
   }
 }
 
-export function LogicalExpression(node: any, parent: any): boolean {
+export function LogicalExpression(
+  node: t.LogicalExpression,
+  parent: t.Node,
+): boolean {
   switch (node.operator) {
     case "||":
       if (!isLogicalExpression(parent)) return false;
diff --git a/packages/babel-generator/src/node/whitespace.ts b/packages/babel-generator/src/node/whitespace.ts
index c9a83a2207e0..8bd234b8045e 100644
--- a/packages/babel-generator/src/node/whitespace.ts
+++ b/packages/babel-generator/src/node/whitespace.ts
@@ -15,8 +15,10 @@ import {
   isStringLiteral,
 } from "@babel/types";
 
+import type { NodeHandlers } from "./index";
+
 import type * as t from "@babel/types";
-type WhitespaceObject = {
+export type WhitespaceObject = {
   before?: boolean;
   after?: boolean;
 };
@@ -72,7 +74,7 @@ function isHelper(node: t.Node): boolean {
   }
 }
 
-function isType(node) {
+function isType(node: t.Node) {
   return (
     isLiteral(node) ||
     isObjectExpression(node) ||
@@ -86,16 +88,7 @@ function isType(node) {
  * Tests for node types that need whitespace.
  */
 
-export const nodes: {
-  [K in string]?: (
-    node: K extends t.Node["type"] ? Extract<t.Node, { type: K }> : t.Node,
-    // todo:
-    // node: K extends keyof typeof t
-    //   ? Extract<typeof t[K], { type: "string" }>
-    //   : t.Node,
-    parent: t.Node,
-  ) => void;
-} = {
+export const nodes: NodeHandlers<WhitespaceObject | undefined | null> = {
   /**
    * Test if AssignmentExpression needs whitespace.
    */
@@ -221,7 +214,7 @@ nodes.ObjectProperty =
   nodes.ObjectMethod =
     function (
       node: t.ObjectProperty | t.ObjectTypeProperty | t.ObjectMethod,
-      parent: any,
+      parent: t.ObjectExpression,
     ): WhitespaceObject | undefined | null {
       if (parent.properties[0] === node) {
         return {
@@ -232,7 +225,7 @@ nodes.ObjectProperty =
 
 nodes.ObjectTypeCallProperty = function (
   node: t.ObjectTypeCallProperty,
-  parent: any,
+  parent: t.ObjectTypeAnnotation,
 ): WhitespaceObject | undefined | null {
   if (parent.callProperties[0] === node && !parent.properties?.length) {
     return {
@@ -243,7 +236,7 @@ nodes.ObjectTypeCallProperty = function (
 
 nodes.ObjectTypeIndexer = function (
   node: t.ObjectTypeIndexer,
-  parent: any,
+  parent: t.ObjectTypeAnnotation,
 ): WhitespaceObject | undefined | null {
   if (
     parent.indexers[0] === node &&
@@ -258,7 +251,7 @@ nodes.ObjectTypeIndexer = function (
 
 nodes.ObjectTypeInternalSlot = function (
   node: t.ObjectTypeInternalSlot,
-  parent: any,
+  parent: t.ObjectTypeAnnotation,
 ): WhitespaceObject | undefined | null {
   if (
     parent.internalSlots[0] === node &&
@@ -276,7 +269,7 @@ nodes.ObjectTypeInternalSlot = function (
  * Returns lists from node types that need whitespace.
  */
 
-export const list = {
+export const list: NodeHandlers<t.Node[]> = {
   /**
    * Return VariableDeclaration declarations init properties.
    */
@@ -314,16 +307,13 @@ export const list = {
     ["LabeledStatement", true],
     ["SwitchStatement", true],
     ["TryStatement", true],
-  ] as Array<[string, any]>
+  ] as const
 ).forEach(function ([type, amounts]) {
-  if (typeof amounts === "boolean") {
-    amounts = { after: amounts, before: amounts };
-  }
   [type as string]
     .concat(FLIPPED_ALIAS_KEYS[type] || [])
     .forEach(function (type) {
       nodes[type] = function () {
-        return amounts;
+        return { after: amounts, before: amounts };
       };
     });
 });
diff --git a/packages/babel-generator/src/printer.ts b/packages/babel-generator/src/printer.ts
index 1bde04f31c63..227fabe71aa6 100644
--- a/packages/babel-generator/src/printer.ts
+++ b/packages/babel-generator/src/printer.ts
@@ -1,7 +1,13 @@
 import Buffer from "./buffer";
+import type { Loc } from "./buffer";
 import * as n from "./node";
 import { isProgram, isFile, isEmptyStatement } from "@babel/types";
 import type * as t from "@babel/types";
+import type {
+  RecordAndTuplePluginOptions,
+  PipelineOperatorPluginOptions,
+} from "@babel/parser";
+import type { Opts as jsescOptions } from "jsesc";
 
 import * as generatorFunctions from "./generators";
 import type SourceMap from "./source-map";
@@ -30,16 +36,35 @@ export type Format = {
     base: number;
   };
   decoratorsBeforeExport: boolean;
-  recordAndTupleSyntaxType: "bar" | "hash";
-  jsescOption;
-  jsonCompatibleStrings?;
+  recordAndTupleSyntaxType: RecordAndTuplePluginOptions["syntaxType"];
+  jsescOption: jsescOptions;
+  jsonCompatibleStrings?: boolean;
   /**
    * For use with the Hack-style pipe operator.
    * Changes what token is used for pipe bodies’ topic references.
    */
-  topicToken?: "#";
+  topicToken?: PipelineOperatorPluginOptions["topicToken"];
 };
 
+interface AddNewlinesOptions {
+  addNewlines(leading: boolean, node: t.Node): number;
+}
+
+interface PrintSequenceOptions extends Partial<AddNewlinesOptions> {
+  statement?: boolean;
+  indent?: boolean;
+}
+
+interface PrintListOptions {
+  separator?: (this: Printer) => void;
+  statement?: boolean;
+  indent?: boolean;
+}
+
+type PrintJoinOptions = PrintListOptions &
+  PrintSequenceOptions & {
+    iterator?: (node: t.Node, index: number) => void;
+  };
 class Printer {
   constructor(format: Format, map: SourceMap) {
     this.format = format;
@@ -53,14 +78,14 @@ class Printer {
   _printStack: Array<t.Node> = [];
   _indent: number = 0;
   _insideAux: boolean = false;
-  _parenPushNewlineState: any = null;
+  _parenPushNewlineState: { printed: boolean } | null = null;
   _noLineTerminator: boolean = false;
   _printAuxAfterOnNextUserNode: boolean = false;
-  _printedComments: WeakSet<any> = new WeakSet();
+  _printedComments = new WeakSet<t.Comment>();
   _endsWithInteger = false;
   _endsWithWord = false;
 
-  generate(ast) {
+  generate(ast: t.Node) {
     this.print(ast);
     this._maybeAddAuxComment();
 
@@ -229,19 +254,23 @@ class Printer {
     this._buf.removeTrailingNewline();
   }
 
-  exactSource(loc: any, cb: () => void) {
+  exactSource(loc: Loc | undefined, cb: () => void) {
     this._catchUp("start", loc);
 
     this._buf.exactSource(loc, cb);
   }
 
-  source(prop: string, loc: any): void {
+  source(prop: "start" | "end", loc: Loc | undefined): void {
     this._catchUp(prop, loc);
 
     this._buf.source(prop, loc);
   }
 
-  withSource(prop: string, loc: any, cb: () => void): void {
+  withSource(
+    prop: "start" | "end",
+    loc: Loc | undefined,
+    cb: () => void,
+  ): void {
     this._catchUp(prop, loc);
 
     this._buf.withSource(prop, loc, cb);
@@ -337,7 +366,7 @@ class Printer {
     parenPushNewlineState.printed = true;
   }
 
-  _catchUp(prop: string, loc: any) {
+  _catchUp(prop: "start" | "end", loc?: Loc) {
     if (!this.format.retainLines) return;
 
     // catch up to this nodes newline if we're behind
@@ -359,55 +388,64 @@ class Printer {
     return this.format.indent.style.repeat(this._indent);
   }
 
-  /**
-   * Set some state that will be modified if a newline has been inserted before any
-   * non-space characters.
-   *
-   * This is to prevent breaking semantics for terminatorless separator nodes. eg:
-   *
-   *   return foo;
-   *
-   * returns `foo`. But if we do:
-   *
-   *   return
-   *   foo;
-   *
-   *  `undefined` will be returned and not `foo` due to the terminator.
-   */
-
-  startTerminatorless(isLabel: boolean = false) {
+  printTerminatorless(node: t.Node, parent: t.Node, isLabel: boolean) {
+    /**
+     * Set some state that will be modified if a newline has been inserted before any
+     * non-space characters.
+     *
+     * This is to prevent breaking semantics for terminatorless separator nodes. eg:
+     *
+     *   return foo;
+     *
+     * returns `foo`. But if we do:
+     *
+     *   return
+     *   foo;
+     *
+     *  `undefined` will be returned and not `foo` due to the terminator.
+     */
     if (isLabel) {
       this._noLineTerminator = true;
-      return null;
+      this.print(node, parent);
+      this._noLineTerminator = false;
     } else {
-      return (this._parenPushNewlineState = {
+      const terminatorState = {
         printed: false,
-      });
-    }
-  }
-
-  /**
-   * Print an ending parentheses if a starting one has been printed.
-   */
-
-  endTerminatorless(state?: any) {
-    this._noLineTerminator = false;
-    if (state?.printed) {
-      this.dedent();
-      this.newline();
-      this.token(")");
+      };
+      this._parenPushNewlineState = terminatorState;
+      this.print(node, parent);
+      /**
+       * Print an ending parentheses if a starting one has been printed.
+       */
+      if (terminatorState.printed) {
+        this.dedent();
+        this.newline();
+        this.token(")");
+      }
     }
   }
 
-  print(node, parent?) {
+  print(node: t.Node | null, parent?: t.Node) {
     if (!node) return;
 
     const oldConcise = this.format.concise;
-    if (node._compact) {
+    if (
+      // @ts-ignore document _compact AST properties
+      node._compact
+    ) {
       this.format.concise = true;
     }
 
-    const printMethod = this[node.type];
+    const printMethod =
+      this[
+        node.type as Exclude<
+          t.Node["type"],
+          // removed
+          | "Noop"
+          // renamed
+          | t.DeprecatedAliases["type"]
+        >
+      ];
     if (!printMethod) {
       throw new ReferenceError(
         `unknown node of type ${JSON.stringify(
@@ -451,7 +489,7 @@ class Printer {
     this._insideAux = oldInAux;
   }
 
-  _maybeAddAuxComment(enteredPositionlessNode?) {
+  _maybeAddAuxComment(enteredPositionlessNode?: boolean) {
     if (enteredPositionlessNode) this._printAuxBeforeComment();
     if (!this._insideAux) this._printAuxAfterComment();
   }
@@ -482,7 +520,15 @@ class Printer {
     }
   }
 
-  getPossibleRaw(node) {
+  getPossibleRaw(
+    node:
+      | t.StringLiteral
+      | t.NumericLiteral
+      | t.BigIntLiteral
+      | t.DecimalLiteral
+      | t.DirectiveLiteral
+      | t.JSXText,
+  ): string | undefined {
     const extra = node.extra;
     if (
       extra &&
@@ -490,16 +536,21 @@ class Printer {
       extra.rawValue != null &&
       node.value === extra.rawValue
     ) {
+      // @ts-expect-error: The extra.raw of these AST node types must be a string
       return extra.raw;
     }
   }
 
-  printJoin(nodes: Array<any> | undefined | null, parent: any, opts: any = {}) {
+  printJoin(
+    nodes: Array<t.Node> | undefined | null,
+    parent: t.Node,
+    opts: PrintJoinOptions = {},
+  ) {
     if (!nodes?.length) return;
 
     if (opts.indent) this.indent();
 
-    const newlineOpts = {
+    const newlineOpts: AddNewlinesOptions = {
       addNewlines: opts.addNewlines,
     };
 
@@ -525,14 +576,14 @@ class Printer {
     if (opts.indent) this.dedent();
   }
 
-  printAndIndentOnComments(node, parent) {
+  printAndIndentOnComments(node: t.Node, parent: t.Node) {
     const indent = node.leadingComments && node.leadingComments.length > 0;
     if (indent) this.indent();
     this.print(node, parent);
     if (indent) this.dedent();
   }
 
-  printBlock(parent) {
+  printBlock(parent: Extract<t.Node, { body: t.Statement }>) {
     const node = parent.body;
 
     if (!isEmptyStatement(node)) {
@@ -542,11 +593,11 @@ class Printer {
     this.print(node, parent);
   }
 
-  _printTrailingComments(node) {
+  _printTrailingComments(node: t.Node) {
     this._printComments(this._getComments(false, node));
   }
 
-  _printLeadingComments(node) {
+  _printLeadingComments(node: t.Node) {
     this._printComments(
       this._getComments(true, node),
       // Don't add leading/trailing new lines to #__PURE__ annotations
@@ -554,7 +605,7 @@ class Printer {
     );
   }
 
-  printInnerComments(node, indent = true) {
+  printInnerComments(node: t.Node, indent = true) {
     if (!node.innerComments?.length) return;
     if (indent) this.indent();
     this._printComments(node.innerComments);
@@ -562,23 +613,15 @@ class Printer {
   }
 
   printSequence(
-    nodes,
-    parent,
-    opts: {
-      statement?: boolean;
-      indent?: boolean;
-      addNewlines?: Function;
-    } = {},
+    nodes: t.Node[],
+    parent: t.Node,
+    opts: PrintSequenceOptions = {},
   ) {
     opts.statement = true;
     return this.printJoin(nodes, parent, opts);
   }
 
-  printList(
-    items,
-    parent,
-    opts: { separator?: Function; indent?: boolean; statement?: boolean } = {},
-  ) {
+  printList(items: t.Node[], parent: t.Node, opts: PrintListOptions = {}) {
     if (opts.separator == null) {
       opts.separator = commaSeparator;
     }
@@ -586,7 +629,12 @@ class Printer {
     return this.printJoin(items, parent, opts);
   }
 
-  _printNewline(leading, node, parent, opts) {
+  _printNewline(
+    leading: boolean,
+    node: t.Node,
+    parent: t.Node,
+    opts: AddNewlinesOptions,
+  ) {
     // Fast path since 'this.newline' does nothing when not tracking lines.
     if (this.format.retainLines || this.format.compact) return;
 
@@ -610,7 +658,7 @@ class Printer {
     this.newline(Math.min(2, lines));
   }
 
-  _getComments(leading, node) {
+  _getComments(leading: boolean, node: t.Node) {
     // Note, we use a boolean flag here instead of passing in the attribute name as it is faster
     // because this is called extremely frequently.
     return (
@@ -618,10 +666,10 @@ class Printer {
     );
   }
 
-  _printComment(comment, skipNewLines?: boolean) {
+  _printComment(comment: t.Comment, skipNewLines?: boolean) {
     if (!this.format.shouldPrintComment(comment.value)) return;
 
-    // Some plugins use this to mark comments as removed using the AST-root 'comments' property,
+    // Some plugins (such as flow-strip-types) use this to mark comments as removed using the AST-root 'comments' property,
     // where they can't manually mutate the AST node comment lists.
     if (comment.ignore) return;
 
@@ -674,7 +722,10 @@ class Printer {
     if (printNewLines) this.newline(1);
   }
 
-  _printComments(comments?: Array<any>, inlinePureAnnotation?: boolean) {
+  _printComments(
+    comments?: readonly t.Comment[],
+    inlinePureAnnotation?: boolean,
+  ) {
     if (!comments?.length) return;
 
     if (
@@ -694,7 +745,7 @@ class Printer {
     }
   }
   // todo(flow->ts): was Node
-  printAssertions(node) {
+  printAssertions(node: Extract<t.Node, { assertions?: t.ImportAttribute[] }>) {
     if (node.assertions?.length) {
       this.space();
       this.word("assert");
diff --git a/packages/babel-helper-annotate-as-pure/src/index.ts b/packages/babel-helper-annotate-as-pure/src/index.ts
index e2644da46e68..f6a92c4fb7ba 100644
--- a/packages/babel-helper-annotate-as-pure/src/index.ts
+++ b/packages/babel-helper-annotate-as-pure/src/index.ts
@@ -1,5 +1,5 @@
-import { addComment } from "@babel/types";
-import type { Node } from "@babel/types";
+import { addComment, type Node } from "@babel/types";
+import type { NodePath } from "@babel/traverse";
 
 const PURE_ANNOTATION = "#__PURE__";
 
@@ -7,10 +7,10 @@ const isPureAnnotated = ({ leadingComments }: Node): boolean =>
   !!leadingComments &&
   leadingComments.some(comment => /[@#]__PURE__/.test(comment.value));
 
-export default function annotateAsPure(
-  pathOrNode: Node | { node: Node },
-): void {
-  const node = pathOrNode["node"] || pathOrNode;
+export default function annotateAsPure(pathOrNode: Node | NodePath): void {
+  const node =
+    // @ts-expect-error Node will not have `node` property
+    (pathOrNode["node"] || pathOrNode) as Node;
   if (isPureAnnotated(node)) {
     return;
   }
diff --git a/packages/babel-helper-builder-binary-assignment-operator-visitor/src/index.ts b/packages/babel-helper-builder-binary-assignment-operator-visitor/src/index.ts
index c498d70369d7..a98fd672aea5 100644
--- a/packages/babel-helper-builder-binary-assignment-operator-visitor/src/index.ts
+++ b/packages/babel-helper-builder-binary-assignment-operator-visitor/src/index.ts
@@ -1,8 +1,15 @@
 import explode from "@babel/helper-explode-assignable-expression";
 import { assignmentExpression, sequenceExpression } from "@babel/types";
 import type { Visitor } from "@babel/traverse";
+import type * as t from "@babel/types";
 
-export default function (opts: { build: Function; operator: string }) {
+export default function (opts: {
+  build: (
+    left: t.Expression | t.PrivateName,
+    right: t.Expression,
+  ) => t.Expression;
+  operator: t.BinaryExpression["operator"];
+}) {
   const { build, operator } = opts;
 
   const visitor: Visitor = {
@@ -10,8 +17,8 @@ export default function (opts: { build: Function; operator: string }) {
       const { node, scope } = path;
       if (node.operator !== operator + "=") return;
 
-      const nodes = [];
-      // @ts-expect-error todo(flow->ts)
+      const nodes: t.AssignmentExpression[] = [];
+      // @ts-expect-error Fixme: node.left can be a TSAsExpression
       const exploded = explode(node.left, nodes, this, scope);
       nodes.push(
         assignmentExpression(
diff --git a/packages/babel-helper-builder-react-jsx/src/index.ts b/packages/babel-helper-builder-react-jsx/src/index.ts
index e9f436afb6fa..f51975543fbc 100644
--- a/packages/babel-helper-builder-react-jsx/src/index.ts
+++ b/packages/babel-helper-builder-react-jsx/src/index.ts
@@ -9,7 +9,6 @@ import {
   isJSXMemberExpression,
   isJSXNamespacedName,
   isJSXSpreadAttribute,
-  isLiteral,
   isObjectExpression,
   isReferenced,
   isStringLiteral,
@@ -24,10 +23,12 @@ import {
   thisExpression,
 } from "@babel/types";
 import annotateAsPure from "@babel/helper-annotate-as-pure";
-import type { Visitor } from "@babel/traverse";
+import type { NodePath, Visitor } from "@babel/traverse";
+import type { PluginPass, File } from "@babel/core";
+import type * as t from "@babel/types";
 
 type ElementState = {
-  tagExpr: any; // tag node,
+  tagExpr: t.Expression; // tag node,
   tagName: string | undefined | null; // raw string tag name,
   args: Array<any>; // array of call arguments,
   call?: any; // optional call property that can be set to override the call expression returned,
@@ -35,8 +36,17 @@ type ElementState = {
   callee?: any;
 };
 
-export default function (opts) {
-  const visitor: Visitor = {};
+export interface Options {
+  filter?: (node: t.Node, file: File) => boolean;
+  pre?: (state: ElementState, file: File) => void;
+  post?: (state: ElementState, file: File) => void;
+  compat?: boolean;
+  pure?: string;
+  throwIfNamespace?: boolean;
+}
+
+export default function (opts: Options) {
+  const visitor: Visitor<PluginPass> = {};
 
   visitor.JSXNamespacedName = function (path) {
     if (opts.throwIfNamespace) {
@@ -54,8 +64,8 @@ You can set \`throwIfNamespace: false\` to bypass this warning.`,
   };
 
   visitor.JSXElement = {
-    exit(path, file) {
-      const callExpr = buildElementCall(path, file);
+    exit(path, state) {
+      const callExpr = buildElementCall(path, state.file);
       if (callExpr) {
         path.replaceWith(inherits(callExpr, path.node));
       }
@@ -63,13 +73,13 @@ You can set \`throwIfNamespace: false\` to bypass this warning.`,
   };
 
   visitor.JSXFragment = {
-    exit(path, file) {
+    exit(path, state) {
       if (opts.compat) {
         throw path.buildCodeFrameError(
           "Fragment tags are only supported in React 16 and up.",
         );
       }
-      const callExpr = buildFragmentCall(path, file);
+      const callExpr = buildFragmentCall(path, state.file);
       if (callExpr) {
         path.replaceWith(inherits(callExpr, path.node));
       }
@@ -78,7 +88,10 @@ You can set \`throwIfNamespace: false\` to bypass this warning.`,
 
   return visitor;
 
-  function convertJSXIdentifier(node, parent) {
+  function convertJSXIdentifier(
+    node: t.JSXIdentifier | t.JSXMemberExpression | t.JSXNamespacedName,
+    parent: t.JSXOpeningElement | t.JSXMemberExpression,
+  ): t.ThisExpression | t.StringLiteral | t.MemberExpression | t.Identifier {
     if (isJSXIdentifier(node)) {
       if (node.name === "this" && isReferenced(node, parent)) {
         return thisExpression();
@@ -101,10 +114,13 @@ You can set \`throwIfNamespace: false\` to bypass this warning.`,
       return stringLiteral(`${node.namespace.name}:${node.name.name}`);
     }
 
+    // @ts-expect-error
     return node;
   }
 
-  function convertAttributeValue(node) {
+  function convertAttributeValue(
+    node: t.JSXAttribute["value"] | t.BooleanLiteral,
+  ) {
     if (isJSXExpressionContainer(node)) {
       return node.expression;
     } else {
@@ -112,12 +128,11 @@ You can set \`throwIfNamespace: false\` to bypass this warning.`,
     }
   }
 
-  function convertAttribute(node) {
-    const value = convertAttributeValue(node.value || booleanLiteral(true));
-
+  function convertAttribute(node: t.JSXAttribute | t.JSXSpreadAttribute) {
     if (isJSXSpreadAttribute(node)) {
       return spreadElement(node.argument);
     }
+    const value = convertAttributeValue(node.value || booleanLiteral(true));
 
     if (isStringLiteral(value) && !isJSXExpressionContainer(node.value)) {
       value.value = value.value.replace(/\n\s+/g, " ");
@@ -127,35 +142,45 @@ You can set \`throwIfNamespace: false\` to bypass this warning.`,
     }
 
     if (isJSXNamespacedName(node.name)) {
+      // @ts-expect-error Mutating AST nodes
       node.name = stringLiteral(
         node.name.namespace.name + ":" + node.name.name.name,
       );
     } else if (isValidIdentifier(node.name.name, false)) {
+      // @ts-expect-error Mutating AST nodes
       node.name.type = "Identifier";
     } else {
+      // @ts-expect-error Mutating AST nodes
       node.name = stringLiteral(node.name.name);
     }
 
-    return inherits(objectProperty(node.name, value), node);
+    return inherits(
+      objectProperty(
+        // @ts-expect-error Mutating AST nodes
+        node.name,
+        value,
+      ),
+      node,
+    );
   }
 
-  function buildElementCall(path, file) {
+  function buildElementCall(path: NodePath<t.JSXElement>, file: File) {
     if (opts.filter && !opts.filter(path.node, file)) return;
 
     const openingPath = path.get("openingElement");
-    openingPath.parent.children = react.buildChildren(openingPath.parent);
+    // @ts-expect-error mutating AST nodes
+    path.node.children = react.buildChildren(path.node);
 
     const tagExpr = convertJSXIdentifier(
       openingPath.node.name,
       openingPath.node,
     );
-    const args = [];
+    const args: (t.Expression | t.JSXElement | t.JSXFragment)[] = [];
 
-    let tagName;
+    let tagName: string;
     if (isIdentifier(tagExpr)) {
       tagName = tagExpr.name;
-    } else if (isLiteral(tagExpr)) {
-      // @ts-expect-error todo(flow->ts) NullLiteral
+    } else if (isStringLiteral(tagExpr)) {
       tagName = tagExpr.value;
     }
 
@@ -170,18 +195,23 @@ You can set \`throwIfNamespace: false\` to bypass this warning.`,
       opts.pre(state, file);
     }
 
-    let attribs = openingPath.node.attributes;
+    const attribs = openingPath.node.attributes;
+    let convertedAttributes: t.Expression;
     if (attribs.length) {
       if (process.env.BABEL_8_BREAKING) {
-        attribs = objectExpression(attribs.map(convertAttribute));
+        convertedAttributes = objectExpression(attribs.map(convertAttribute));
       } else {
-        attribs = buildOpeningElementAttributes(attribs, file);
+        convertedAttributes = buildOpeningElementAttributes(attribs, file);
       }
     } else {
-      attribs = nullLiteral();
+      convertedAttributes = nullLiteral();
     }
 
-    args.push(attribs, ...path.node.children);
+    args.push(
+      convertedAttributes,
+      // @ts-expect-error JSXExpressionContainer has been transformed by convertAttributeValue
+      ...path.node.children,
+    );
 
     if (opts.post) {
       opts.post(state, file);
@@ -193,7 +223,10 @@ You can set \`throwIfNamespace: false\` to bypass this warning.`,
     return call;
   }
 
-  function pushProps(_props, objs) {
+  function pushProps(
+    _props: (t.ObjectProperty | t.SpreadElement)[],
+    objs: t.Expression[],
+  ) {
     if (!_props.length) return _props;
 
     objs.push(objectExpression(_props));
@@ -207,9 +240,12 @@ You can set \`throwIfNamespace: false\` to bypass this warning.`,
    * all prior attributes to an array for later processing.
    */
 
-  function buildOpeningElementAttributes(attribs, file) {
-    let _props = [];
-    const objs = [];
+  function buildOpeningElementAttributes(
+    attribs: (t.JSXAttribute | t.JSXSpreadAttribute)[],
+    file: File,
+  ): t.Expression {
+    let _props: (t.ObjectProperty | t.SpreadElement)[] = [];
+    const objs: t.Expression[] = [];
 
     const { useSpread = false } = file.opts;
     if (typeof useSpread !== "boolean") {
@@ -250,10 +286,11 @@ You can set \`throwIfNamespace: false\` to bypass this warning.`,
     }
 
     pushProps(_props, objs);
+    let convertedAttribs: t.Expression;
 
     if (objs.length === 1) {
       // only one object
-      attribs = objs[0];
+      convertedAttribs = objs[0];
     } else {
       // looks like we have multiple objects
       if (!isObjectExpression(objs[0])) {
@@ -265,20 +302,20 @@ You can set \`throwIfNamespace: false\` to bypass this warning.`,
         : file.addHelper("extends");
 
       // spread it
-      attribs = callExpression(helper, objs);
+      convertedAttribs = callExpression(helper, objs);
     }
 
-    return attribs;
+    return convertedAttribs;
   }
 
-  function buildFragmentCall(path, file) {
+  function buildFragmentCall(path: NodePath<t.JSXFragment>, file: File) {
     if (opts.filter && !opts.filter(path.node, file)) return;
 
-    const openingPath = path.get("openingElement");
-    openingPath.parent.children = react.buildChildren(openingPath.parent);
+    // @ts-expect-error mutating AST nodes
+    path.node.children = react.buildChildren(path.node);
 
-    const args = [];
-    const tagName = null;
+    const args: t.Expression[] = [];
+    const tagName: null = null;
     const tagExpr = file.get("jsxFragIdentifier")();
 
     const state: ElementState = {
@@ -293,7 +330,11 @@ You can set \`throwIfNamespace: false\` to bypass this warning.`,
     }
 
     // no attributes are allowed with <> syntax
-    args.push(nullLiteral(), ...path.node.children);
+    args.push(
+      nullLiteral(),
+      // @ts-expect-error JSXExpressionContainer has been transformed by convertAttributeValue
+      ...path.node.children,
+    );
 
     if (opts.post) {
       opts.post(state, file);
diff --git a/packages/babel-helper-check-duplicate-nodes/src/index.ts b/packages/babel-helper-check-duplicate-nodes/src/index.ts
index 949c5c2a7871..2f44f4215c79 100644
--- a/packages/babel-helper-check-duplicate-nodes/src/index.ts
+++ b/packages/babel-helper-check-duplicate-nodes/src/index.ts
@@ -1,20 +1,25 @@
 import { VISITOR_KEYS } from "@babel/types";
+import type * as t from "@babel/types";
 
-export default function checkDuplicateNodes(ast) {
+type StackItem = {
+  node: t.Node;
+  parent: t.Node | null;
+};
+export default function checkDuplicateNodes(ast: t.Node) {
   if (arguments.length !== 1) {
     throw new Error("checkDuplicateNodes accepts only one argument: ast");
   }
   // A Map from node to its parent
   const parentsMap = new Map();
 
-  const hidePrivateProperties = (key, val) => {
+  const hidePrivateProperties = (key: string, val: unknown) => {
     // Hides properties like _shadowedFunctionLiteral,
     // which makes the AST circular
     if (key[0] === "_") return "[Private]";
     return val;
   };
 
-  const stack = [{ node: ast, parent: null }];
+  const stack: StackItem[] = [{ node: ast, parent: null }];
   let item;
 
   while ((item = stack.pop()) !== undefined) {
@@ -36,7 +41,9 @@ export default function checkDuplicateNodes(ast) {
     parentsMap.set(node, parent);
 
     for (const key of keys) {
-      const subNode = node[key];
+      const subNode =
+        // @ts-expect-error visitor keys must present in node
+        node[key];
 
       if (Array.isArray(subNode)) {
         for (const child of subNode) {
diff --git a/packages/babel-helper-compilation-targets/src/debug.ts b/packages/babel-helper-compilation-targets/src/debug.ts
index aef9fc12a249..d1ee514cd980 100644
--- a/packages/babel-helper-compilation-targets/src/debug.ts
+++ b/packages/babel-helper-compilation-targets/src/debug.ts
@@ -34,5 +34,5 @@ export function getInclusionReasons(
     }
 
     return result;
-  }, {});
+  }, {} as Partial<Record<Target, string>>);
 }
diff --git a/packages/babel-helper-compilation-targets/src/index.ts b/packages/babel-helper-compilation-targets/src/index.ts
index 31b9c40d0e27..b1bfbd17fe2f 100644
--- a/packages/babel-helper-compilation-targets/src/index.ts
+++ b/packages/babel-helper-compilation-targets/src/index.ts
@@ -12,7 +12,14 @@ import {
 import { OptionValidator } from "@babel/helper-validator-option";
 import { browserNameMap } from "./targets";
 import { TargetNames } from "./options";
-import type { Targets, InputTargets, Browsers, TargetsTuple } from "./types";
+import type {
+  Target,
+  Targets,
+  InputTargets,
+  Browsers,
+  BrowserslistBrowserName,
+  TargetsTuple,
+} from "./types";
 
 export type { Targets, InputTargets };
 
@@ -58,50 +65,49 @@ function validateBrowsers(browsers: Browsers | undefined) {
 }
 
 function getLowestVersions(browsers: Array<string>): Targets {
-  return browsers.reduce((all: any, browser: string): any => {
-    const [browserName, browserVersion] = browser.split(" ");
-    const normalizedBrowserName = browserNameMap[browserName];
-
-    if (!normalizedBrowserName) {
+  return browsers.reduce((all, browser) => {
+    const [browserName, browserVersion] = browser.split(" ") as [
+      BrowserslistBrowserName,
+      string,
+    ];
+    const target: Target = browserNameMap[browserName];
+
+    if (!target) {
       return all;
     }
 
     try {
       // Browser version can return as "10.0-10.2"
       const splitVersion = browserVersion.split("-")[0].toLowerCase();
-      const isSplitUnreleased = isUnreleasedVersion(splitVersion, browserName);
+      const isSplitUnreleased = isUnreleasedVersion(splitVersion, target);
 
-      if (!all[normalizedBrowserName]) {
-        all[normalizedBrowserName] = isSplitUnreleased
+      if (!all[target]) {
+        all[target] = isSplitUnreleased
           ? splitVersion
           : semverify(splitVersion);
         return all;
       }
 
-      const version = all[normalizedBrowserName];
-      const isUnreleased = isUnreleasedVersion(version, browserName);
+      const version = all[target];
+      const isUnreleased = isUnreleasedVersion(version, target);
 
       if (isUnreleased && isSplitUnreleased) {
-        all[normalizedBrowserName] = getLowestUnreleased(
-          version,
-          splitVersion,
-          browserName,
-        );
+        all[target] = getLowestUnreleased(version, splitVersion, target);
       } else if (isUnreleased) {
-        all[normalizedBrowserName] = semverify(splitVersion);
+        all[target] = semverify(splitVersion);
       } else if (!isUnreleased && !isSplitUnreleased) {
         const parsedBrowserVersion = semverify(splitVersion);
 
-        all[normalizedBrowserName] = semverMin(version, parsedBrowserVersion);
+        all[target] = semverMin(version, parsedBrowserVersion);
       }
     } catch (e) {}
 
     return all;
-  }, {});
+  }, {} as Record<Target, string>);
 }
 
 function outputDecimalWarning(
-  decimalTargets: Array<{ target: string; value: string }>,
+  decimalTargets: Array<{ target: string; value: number }>,
 ): void {
   if (!decimalTargets.length) {
     return;
@@ -117,7 +123,7 @@ getting parsed as 6.1, which can lead to unexpected behavior.
 `);
 }
 
-function semverifyTarget(target, value) {
+function semverifyTarget(target: keyof Targets, value: string) {
   try {
     return semverify(value);
   } catch (error) {
@@ -129,23 +135,24 @@ function semverifyTarget(target, value) {
   }
 }
 
-const targetParserMap = {
-  __default(target, value) {
-    const version = isUnreleasedVersion(value, target)
-      ? value.toLowerCase()
-      : semverifyTarget(target, value);
-    return [target, version];
-  },
-
-  // Parse `node: true` and `node: "current"` to version
-  node(target, value) {
-    const parsed =
-      value === true || value === "current"
-        ? process.versions.node
-        : semverifyTarget(target, value);
-    return [target, parsed];
-  },
-};
+// Parse `node: true` and `node: "current"` to version
+function nodeTargetParser(value: true | string) {
+  const parsed =
+    value === true || value === "current"
+      ? process.versions.node
+      : semverifyTarget("node", value);
+  return ["node" as const, parsed] as const;
+}
+
+function defaultTargetParser(
+  target: Exclude<Target, "node">,
+  value: string,
+): readonly [Exclude<Target, "node">, string] {
+  const version = isUnreleasedVersion(value, target)
+    ? value.toLowerCase()
+    : semverifyTarget(target, value);
+  return [target, version] as const;
+}
 
 function generateTargets(inputTargets: InputTargets): Targets {
   const input = { ...inputTargets };
@@ -214,7 +221,10 @@ export default function getTargets(
   // These values OVERRIDE the `browsers` field.
   if (esmodules && (esmodules !== "intersect" || !browsers?.length)) {
     browsers = Object.keys(ESM_SUPPORT)
-      .map(browser => `${browser} >= ${ESM_SUPPORT[browser]}`)
+      .map(
+        (browser: keyof typeof ESM_SUPPORT) =>
+          `${browser} >= ${ESM_SUPPORT[browser]}`,
+      )
       .join(", ");
     esmodules = false;
   }
@@ -226,13 +236,16 @@ export default function getTargets(
     const queryBrowsers = resolveTargets(browsers, options.browserslistEnv);
 
     if (esmodules === "intersect") {
-      for (const browser of Object.keys(queryBrowsers)) {
+      for (const browser of Object.keys(queryBrowsers) as Target[]) {
         const version = queryBrowsers[browser];
+        const esmSupportVersion =
+          // @ts-ignore ie is not in ESM_SUPPORT
+          ESM_SUPPORT[browser];
 
-        if (ESM_SUPPORT[browser]) {
+        if (esmSupportVersion) {
           queryBrowsers[browser] = getHighestUnreleased(
             version,
-            semverify(ESM_SUPPORT[browser]),
+            semverify(esmSupportVersion),
             browser,
           );
         } else {
@@ -247,7 +260,7 @@ export default function getTargets(
   // Parse remaining targets
   const result: Targets = {} as Targets;
   const decimalWarnings = [];
-  for (const target of Object.keys(targets).sort()) {
+  for (const target of Object.keys(targets).sort() as Target[]) {
     const value = targets[target];
 
     // Warn when specifying minor/patch as a decimal
@@ -255,10 +268,10 @@ export default function getTargets(
       decimalWarnings.push({ target, value });
     }
 
-    // Check if we have a target parser?
-    // $FlowIgnore - Flow doesn't like that some targetParserMap[target] might be missing
-    const parser = targetParserMap[target] ?? targetParserMap.__default;
-    const [parsedTarget, parsedValue] = parser(target, value);
+    const [parsedTarget, parsedValue] =
+      target === "node"
+        ? nodeTargetParser(value)
+        : defaultTargetParser(target, value as string);
 
     if (parsedValue) {
       // Merge (lowest wins)
diff --git a/packages/babel-helper-compilation-targets/src/pretty.ts b/packages/babel-helper-compilation-targets/src/pretty.ts
index 10afed440b75..34f5257b15ae 100644
--- a/packages/babel-helper-compilation-targets/src/pretty.ts
+++ b/packages/babel-helper-compilation-targets/src/pretty.ts
@@ -1,6 +1,6 @@
 import semver from "semver";
 import { unreleasedLabels } from "./targets";
-import type { Targets } from "./types";
+import type { Targets, Target } from "./types";
 
 export function prettifyVersion(version: string) {
   if (typeof version !== "string") {
@@ -23,10 +23,12 @@ export function prettifyVersion(version: string) {
 }
 
 export function prettifyTargets(targets: Targets): Targets {
-  return Object.keys(targets).reduce((results, target) => {
+  return Object.keys(targets).reduce((results, target: Target) => {
     let value = targets[target];
 
-    const unreleasedLabel = unreleasedLabels[target];
+    const unreleasedLabel =
+      // @ts-expect-error undefined is strictly compared with string later
+      unreleasedLabels[target];
     if (typeof value === "string" && unreleasedLabel !== value) {
       value = prettifyVersion(value);
     }
diff --git a/packages/babel-helper-compilation-targets/src/targets.ts b/packages/babel-helper-compilation-targets/src/targets.ts
index 401d7904a995..ff08703a6492 100644
--- a/packages/babel-helper-compilation-targets/src/targets.ts
+++ b/packages/babel-helper-compilation-targets/src/targets.ts
@@ -1,8 +1,11 @@
 export const unreleasedLabels = {
   safari: "tp",
-};
+} as const;
 
-export const browserNameMap = {
+import type { Target } from "./types";
+
+// Map from browserslist|@mdn/browser-compat-data browser names to @kangax/compat-table browser names
+export const browserNameMap: Record<string, Target> = {
   and_chr: "chrome",
   and_ff: "firefox",
   android: "android",
@@ -17,4 +20,6 @@ export const browserNameMap = {
   opera: "opera",
   safari: "safari",
   samsung: "samsung",
-};
+} as const;
+
+export type BrowserslistBrowserName = keyof typeof browserNameMap;
diff --git a/packages/babel-helper-compilation-targets/src/types.ts b/packages/babel-helper-compilation-targets/src/types.ts
index 00035a1f0e14..d17f15299333 100644
--- a/packages/babel-helper-compilation-targets/src/types.ts
+++ b/packages/babel-helper-compilation-targets/src/types.ts
@@ -1,4 +1,4 @@
-// Targets
+// Targets, engine names defined in compat-tables
 export type Target =
   | "node"
   | "chrome"
@@ -17,7 +17,9 @@ export type Targets = {
 };
 
 export type TargetsTuple = {
-  [target in Target]: string;
+  [target in Exclude<Target, "node">]: string;
+} & {
+  node: string | true;
 };
 
 export type Browsers = string | ReadonlyArray<string>;
@@ -31,3 +33,5 @@ export type InputTargets = {
   // remove `intersect`.
   esmodules?: boolean | "intersect";
 } & Targets;
+
+export type { BrowserslistBrowserName } from "./targets";
diff --git a/packages/babel-helper-compilation-targets/src/utils.ts b/packages/babel-helper-compilation-targets/src/utils.ts
index d527247e9fc0..2beea6b0404e 100644
--- a/packages/babel-helper-compilation-targets/src/utils.ts
+++ b/packages/babel-helper-compilation-targets/src/utils.ts
@@ -38,20 +38,27 @@ export function semverify(version: number | string): string {
 
 export function isUnreleasedVersion(
   version: string | number,
-  env: string,
+  env: Target,
 ): boolean {
-  const unreleasedLabel = unreleasedLabels[env];
+  const unreleasedLabel =
+    // @ts-expect-error unreleasedLabel will be guarded later
+    unreleasedLabels[env];
   return (
     !!unreleasedLabel && unreleasedLabel === version.toString().toLowerCase()
   );
 }
 
-export function getLowestUnreleased(a: string, b: string, env: string): string {
-  const unreleasedLabel = unreleasedLabels[env];
-  const hasUnreleased = [a, b].some(item => item === unreleasedLabel);
-  if (hasUnreleased) {
-    // @ts-expect-error todo(flow->ts): probably a bug - types of a hasUnreleased to not overlap
-    return a === hasUnreleased ? b : a || b;
+export function getLowestUnreleased(a: string, b: string, env: Target): string {
+  const unreleasedLabel:
+    | typeof unreleasedLabels[keyof typeof unreleasedLabels]
+    | undefined =
+    // @ts-ignore unreleasedLabel is undefined when env is not safari
+    unreleasedLabels[env];
+  if (a === unreleasedLabel) {
+    return b;
+  }
+  if (b === unreleasedLabel) {
+    return a;
   }
   return semverMin(a, b);
 }
@@ -59,7 +66,7 @@ export function getLowestUnreleased(a: string, b: string, env: string): string {
 export function getHighestUnreleased(
   a: string,
   b: string,
-  env: string,
+  env: Target,
 ): string {
   return getLowestUnreleased(a, b, env) === a ? b : a;
 }
diff --git a/packages/babel-helper-create-class-features-plugin/src/decorators.ts b/packages/babel-helper-create-class-features-plugin/src/decorators.ts
index bb80db63a7db..ef34aa56f399 100644
--- a/packages/babel-helper-create-class-features-plugin/src/decorators.ts
+++ b/packages/babel-helper-create-class-features-plugin/src/decorators.ts
@@ -108,9 +108,20 @@ function extractElementDescriptor(
   ].filter(Boolean);
 
   if (t.isClassMethod(node)) {
-    const id = node.computed ? null : node.key;
-    t.toExpression(node);
-    properties.push(prop("value", nameFunction({ node, id, scope }) || node));
+    const id = node.computed
+      ? null
+      : (node.key as
+          | t.Identifier
+          | t.StringLiteral
+          | t.NumericLiteral
+          | t.BigIntLiteral);
+    const transformed = t.toExpression(node);
+    properties.push(
+      prop(
+        "value",
+        nameFunction({ node: transformed, id, scope }) || transformed,
+      ),
+    );
   } else if (t.isClassProperty(node) && node.value) {
     properties.push(
       method("value", template.statements.ast`return ${node.value}`),
diff --git a/packages/babel-helper-create-class-features-plugin/src/fields.ts b/packages/babel-helper-create-class-features-plugin/src/fields.ts
index d938e0a9ce7a..24e0a46ed0c4 100644
--- a/packages/babel-helper-create-class-features-plugin/src/fields.ts
+++ b/packages/babel-helper-create-class-features-plugin/src/fields.ts
@@ -107,6 +107,7 @@ interface PrivateNameVisitorState {
 function privateNameVisitorFactory<S>(
   visitor: Visitor<PrivateNameVisitorState & S>,
 ) {
+  // @ts-ignore Fixme: TS complains _exploded: boolean does not satisfy visitor functions
   const privateNameVisitor: Visitor<PrivateNameVisitorState & S> = {
     ...visitor,
 
@@ -490,7 +491,15 @@ export function transformPrivateNamesUsage(
   ref: t.Identifier,
   path: NodePath<t.Class>,
   privateNamesMap: PrivateNamesMap,
-  { privateFieldsAsProperties, noDocumentAll, innerBinding },
+  {
+    privateFieldsAsProperties,
+    noDocumentAll,
+    innerBinding,
+  }: {
+    privateFieldsAsProperties: boolean;
+    noDocumentAll: boolean;
+    innerBinding: t.Identifier;
+  },
   state: File,
 ) {
   if (!privateNamesMap.size) return;
@@ -539,7 +548,7 @@ function buildPrivateInstanceFieldInitSpec(
   ref: t.Expression,
   prop: NodePath<t.ClassPrivateProperty>,
   privateNamesMap: PrivateNamesMap,
-  state,
+  state: File,
 ) {
   const { id } = privateNamesMap.get(prop.node.key.id.name);
   const value = prop.node.value || prop.scope.buildUndefinedNode();
@@ -646,7 +655,7 @@ function buildPrivateInstanceMethodInitSpec(
   ref: t.Expression,
   prop: NodePath<t.ClassPrivateMethod>,
   privateNamesMap: PrivateNamesMap,
-  state,
+  state: File,
 ) {
   const privateName = privateNamesMap.get(prop.node.key.id.name);
   const { getId, setId, initAdded } = privateName;
@@ -675,7 +684,7 @@ function buildPrivateAccessorInitialization(
   ref: t.Expression,
   prop: NodePath<t.ClassPrivateMethod>,
   privateNamesMap: PrivateNamesMap,
-  state,
+  state: File,
 ) {
   const privateName = privateNamesMap.get(prop.node.key.id.name);
   const { id, getId, setId } = privateName;
@@ -711,7 +720,7 @@ function buildPrivateInstanceMethodInitalization(
   ref: t.Expression,
   prop: NodePath<t.ClassPrivateMethod>,
   privateNamesMap: PrivateNamesMap,
-  state,
+  state: File,
 ) {
   const privateName = privateNamesMap.get(prop.node.key.id.name);
   const { id } = privateName;
@@ -748,7 +757,7 @@ function buildPublicFieldInitLoose(
 function buildPublicFieldInitSpec(
   ref: t.Expression,
   prop: NodePath<t.ClassProperty>,
-  state,
+  state: File,
 ) {
   const { key, computed } = prop.node;
   const value = prop.node.value || prop.scope.buildUndefinedNode();
@@ -767,7 +776,7 @@ function buildPublicFieldInitSpec(
 function buildPrivateStaticMethodInitLoose(
   ref: t.Expression,
   prop: NodePath<t.ClassPrivateMethod>,
-  state,
+  state: File,
   privateNamesMap: PrivateNamesMap,
 ) {
   const privateName = privateNamesMap.get(prop.node.key.id.name);
diff --git a/packages/babel-helper-create-regexp-features-plugin/src/index.ts b/packages/babel-helper-create-regexp-features-plugin/src/index.ts
index 34bd564024ed..060a3638f94d 100644
--- a/packages/babel-helper-create-regexp-features-plugin/src/index.ts
+++ b/packages/babel-helper-create-regexp-features-plugin/src/index.ts
@@ -1,6 +1,7 @@
 import rewritePattern from "regexpu-core";
 import { featuresKey, FEATURES, enableFeature, runtimeKey } from "./features";
 import { generateRegexpuOptions, canSkipRegexpu, transformFlags } from "./util";
+import type { NodePath } from "@babel/traverse";
 
 import { types as t } from "@babel/core";
 import type { PluginObject } from "@babel/core";
@@ -17,12 +18,22 @@ const version = PACKAGE_JSON.version
   .reduce((v, x) => v * 1e5 + +x, 0);
 const versionKey = "@babel/plugin-regexp-features/version";
 
+export interface Options {
+  name: string;
+  feature: keyof typeof FEATURES;
+  options?: {
+    useUnicodeFlag?: boolean;
+    runtime?: boolean;
+  };
+  manipulateOptions?: PluginObject["manipulateOptions"];
+}
+
 export function createRegExpFeaturePlugin({
   name,
   feature,
-  options = {} as any,
-  manipulateOptions = (() => {}) as PluginObject["manipulateOptions"],
-}): PluginObject {
+  options = {},
+  manipulateOptions = () => {},
+}: Options): PluginObject {
   return {
     name,
 
@@ -60,7 +71,7 @@ export function createRegExpFeaturePlugin({
         const regexpuOptions = generateRegexpuOptions(features);
         if (canSkipRegexpu(node, regexpuOptions)) return;
 
-        const namedCaptureGroups = {};
+        const namedCaptureGroups: Record<string, number> = {};
         if (regexpuOptions.namedGroups === "transform") {
           regexpuOptions.onNamedGroup = (name, index) => {
             namedCaptureGroups[name] = index;
@@ -90,7 +101,7 @@ export function createRegExpFeaturePlugin({
   };
 }
 
-function isRegExpTest(path) {
+function isRegExpTest(path: NodePath<t.RegExpLiteral>) {
   return (
     path.parentPath.isMemberExpression({
       object: path.node,
diff --git a/packages/babel-helper-create-regexp-features-plugin/src/util.ts b/packages/babel-helper-create-regexp-features-plugin/src/util.ts
index b8126ad009b3..b4c7e5251dfc 100644
--- a/packages/babel-helper-create-regexp-features-plugin/src/util.ts
+++ b/packages/babel-helper-create-regexp-features-plugin/src/util.ts
@@ -1,14 +1,7 @@
 import type { types as t } from "@babel/core";
 import { FEATURES, hasFeature } from "./features";
 
-type RegexpuOptions = {
-  unicodeFlag: "transform" | false;
-  unicodeSetsFlag: "transform" | "parse" | false;
-  dotAllFlag: "transform" | false;
-  unicodePropertyEscapes: "transform" | false;
-  namedGroups: "transform" | false;
-  onNamedGroup: (name: string, index: number) => void;
-};
+import type { RegexpuOptions } from "regexpu-core";
 
 export function generateRegexpuOptions(toTransform: number): RegexpuOptions {
   type Experimental = 1;
diff --git a/packages/babel-helper-define-map/src/index.ts b/packages/babel-helper-define-map/src/index.ts
index 0653c7991744..c303e022632f 100644
--- a/packages/babel-helper-define-map/src/index.ts
+++ b/packages/babel-helper-define-map/src/index.ts
@@ -17,8 +17,11 @@ import {
   toComputedKey,
   toKeyAlias,
 } from "@babel/types";
+import type { File } from "@babel/core";
+import type * as t from "@babel/types";
+import type { Scope } from "@babel/traverse";
 
-function toKind(node: any) {
+function toKind(node: t.Property | t.Method) {
   if (isClassMethod(node) || isObjectMethod(node)) {
     if (node.kind === "get" || node.kind === "set") {
       return node.kind;
@@ -30,12 +33,32 @@ function toKind(node: any) {
 
 const has = Function.prototype.call.bind(Object.prototype.hasOwnProperty);
 
-export function push(mutatorMap: any, node: any, kind: string, file, scope?) {
+type DefineMap = {
+  decorators: t.ArrayExpression;
+  _computed: boolean;
+  _inherits: t.Node[];
+  _key: t.Expression | t.PrivateName;
+  value?: t.Expression;
+  initializer?: t.Expression;
+  get?: t.Expression;
+  set?: t.Expression;
+  kind: "get" | "set" | "value" | "initializer";
+};
+
+export type MutatorMap = Record<string, DefineMap>;
+
+export function push(
+  mutatorMap: MutatorMap,
+  node: t.Property | t.Method,
+  kind: DefineMap["kind"],
+  file: File,
+  scope?: Scope,
+) {
   const alias = toKeyAlias(node);
 
   //
 
-  let map = {} as any;
+  let map = {} as DefineMap;
   if (has(mutatorMap, alias)) map = mutatorMap[alias];
   mutatorMap[alias] = map;
 
@@ -46,7 +69,10 @@ export function push(mutatorMap: any, node: any, kind: string, file, scope?) {
 
   map._key = node.key;
 
-  if (node.computed) {
+  if (
+    // @ts-expect-error computed is not in private property
+    node.computed
+  ) {
     map._computed = true;
   }
 
@@ -69,7 +95,7 @@ export function push(mutatorMap: any, node: any, kind: string, file, scope?) {
   }
 
   if (isProperty(node)) {
-    value = node.value;
+    value = node.value as t.Expression;
   } else if (isObjectMethod(node) || isClassMethod(node)) {
     value = functionExpression(
       null,
diff --git a/packages/babel-helper-explode-assignable-expression/src/index.ts b/packages/babel-helper-explode-assignable-expression/src/index.ts
index deaebcc99b60..01762222cdaa 100644
--- a/packages/babel-helper-explode-assignable-expression/src/index.ts
+++ b/packages/babel-helper-explode-assignable-expression/src/index.ts
@@ -78,7 +78,7 @@ export default function (
   scope: Scope,
   allowedSingleIdent?: boolean,
 ): {
-  uid: t.Identifier | t.MemberExpression;
+  uid: t.Identifier | t.MemberExpression | t.Super;
   ref: t.Identifier | t.MemberExpression;
 } {
   let obj;
diff --git a/packages/babel-helper-fixtures/src/index.ts b/packages/babel-helper-fixtures/src/index.ts
index 8f3189881b0e..c1119cb2bbed 100644
--- a/packages/babel-helper-fixtures/src/index.ts
+++ b/packages/babel-helper-fixtures/src/index.ts
@@ -3,56 +3,81 @@ import path from "path";
 import fs from "fs";
 import { fileURLToPath } from "url";
 import { createRequire } from "module";
+import type { InputOptions } from "@babel/core";
+import type { EncodedSourceMap, Mapping } from "@jridgewell/gen-mapping";
 
 const require = createRequire(import.meta.url);
 
 const nodeVersion = semver.clean(process.version.slice(1));
 
-function humanize(val, noext?) {
+function humanize(val: string, noext?: boolean) {
   if (noext) val = path.basename(val, path.extname(val));
   return val.replace(/-/g, " ");
 }
 
-type TestFile = {
+interface TestIO {
   loc: string;
   code: string;
+}
+
+export interface TestFile extends TestIO {
   filename: string;
-};
+}
 
-type Test = {
+export interface Test {
+  taskDir: string;
   title: string;
   disabled: boolean;
-  options: any;
+  options: TaskOptions;
+  optionsDir: string;
+  doNotSetSourceType: boolean;
+  externalHelpers: boolean;
+  ignoreOutput: boolean;
+  stdout: TestIO;
+  stderr: TestIO;
   exec: TestFile;
   actual: TestFile;
-  expected: TestFile;
-  // todo(flow->ts): improve types here
-  sourceMappings;
-  sourceMap;
+  expect: TestFile;
+  inputSourceMap?: EncodedSourceMap;
+  sourceMappings?: Mapping[];
+  sourceMap: string;
   sourceMapFile: TestFile;
-};
+  validateLogs: boolean;
+}
+
+export interface TaskOptions extends InputOptions {
+  BABEL_8_BREAKING?: boolean;
+  DO_NOT_SET_SOURCE_TYPE?: boolean;
+  externalHelpers?: boolean;
+  ignoreOutput?: boolean;
+  minNodeVersion?: string;
+  sourceMap?: boolean;
+  os?: string | string[];
+  validateLogs?: boolean;
+  throws?: boolean | string;
+}
 
 type Suite = {
-  options: any;
+  options: TaskOptions;
   tests: Array<Test>;
   title: string;
   filename: string;
 };
 
-function tryResolve(module) {
+function tryResolve(module: string) {
   try {
     return require.resolve(module);
   } catch (e) {
     return null;
   }
 }
-function assertDirectory(loc) {
+function assertDirectory(loc: string) {
   if (!fs.statSync(loc).isDirectory()) {
     throw new Error(`Expected ${loc} to be a directory.`);
   }
 }
 
-function shouldIgnore(name, ignore?: Array<string>) {
+function shouldIgnore(name: string, ignore?: Array<string>) {
   if (ignore && ignore.indexOf(name) >= 0) {
     return true;
   }
@@ -87,7 +112,12 @@ function findFile(filepath: string, allowJSON?: boolean) {
   return matches[0];
 }
 
-function pushTask(taskName, taskDir, suite, suiteName) {
+function pushTask(
+  taskName: string,
+  taskDir: string,
+  suite: Suite,
+  suiteName: string,
+) {
   const taskDirStats = fs.statSync(taskDir);
   let actualLoc = findFile(taskDir + "/input");
   let execLoc = findFile(taskDir + "/exec");
@@ -126,12 +156,12 @@ function pushTask(taskName, taskDir, suite, suiteName) {
     execLocAlias = suiteName + "/" + taskName;
   }
 
-  const taskOpts = JSON.parse(JSON.stringify(suite.options));
+  const taskOpts: TaskOptions = JSON.parse(JSON.stringify(suite.options));
 
   const taskOptsLoc = tryResolve(taskDir + "/options");
   if (taskOptsLoc) Object.assign(taskOpts, require(taskOptsLoc));
 
-  const test = {
+  const test: Test = {
     taskDir,
     optionsDir: taskOptsLoc ? path.dirname(taskOptsLoc) : null,
     title: humanize(taskName, true),
@@ -264,7 +294,7 @@ function pushTask(taskName, taskDir, suite, suiteName) {
         (test.stdout.code ? stdoutLoc : stderrLoc),
     );
   }
-  if (test.options.ignoreOutput) {
+  if (test.ignoreOutput) {
     if (test.expect.code) {
       throw new Error(
         "Test cannot ignore its output and also validate it: " + expectLoc,
@@ -284,7 +314,11 @@ function pushTask(taskName, taskDir, suite, suiteName) {
   delete test.options.externalHelpers;
 }
 
-function wrapPackagesArray(type, names, optionsDir) {
+function wrapPackagesArray(
+  type: "plugin" | "preset",
+  names: (string | [string, object?, string?])[],
+  optionsDir: string,
+) {
   return names.map(function (val) {
     if (typeof val === "string") val = [val];
 
@@ -362,10 +396,10 @@ export function resolveOptionPluginOrPreset(
   return options;
 }
 
-export default function get(entryLoc): Array<Suite> {
+export default function get(entryLoc: string): Array<Suite> {
   const suites = [];
 
-  let rootOpts = {};
+  let rootOpts: TaskOptions = {};
   const rootOptsLoc = tryResolve(entryLoc + "/options");
   if (rootOptsLoc) rootOpts = require(rootOptsLoc);
 
@@ -374,7 +408,7 @@ export default function get(entryLoc): Array<Suite> {
 
     const suite = {
       options: { ...rootOpts },
-      tests: [],
+      tests: [] as Test[],
       title: humanize(suiteName),
       filename: entryLoc + "/" + suiteName,
     };
@@ -398,8 +432,8 @@ export default function get(entryLoc): Array<Suite> {
   return suites;
 }
 
-export function multiple(entryLoc, ignore?: Array<string>) {
-  const categories = {};
+export function multiple(entryLoc: string, ignore?: Array<string>) {
+  const categories: Record<string, unknown> = {};
 
   for (const name of fs.readdirSync(entryLoc)) {
     if (shouldIgnore(name, ignore)) continue;
@@ -413,7 +447,7 @@ export function multiple(entryLoc, ignore?: Array<string>) {
   return categories;
 }
 
-export function readFile(filename) {
+export function readFile(filename: string) {
   if (fs.existsSync(filename)) {
     let file = fs.readFileSync(filename, "utf8").trimRight();
     file = file.replace(/\r\n/g, "\n");
diff --git a/packages/babel-helper-function-name/src/index.ts b/packages/babel-helper-function-name/src/index.ts
index fc157b28be35..1f854bb5895d 100644
--- a/packages/babel-helper-function-name/src/index.ts
+++ b/packages/babel-helper-function-name/src/index.ts
@@ -18,6 +18,7 @@ import {
   toBindingIdentifierName,
 } from "@babel/types";
 import type * as t from "@babel/types";
+import type { NodePath, Scope, Visitor } from "@babel/traverse";
 
 function getFunctionArity(node: t.Function): number {
   const count = node.params.findIndex(
@@ -26,7 +27,7 @@ function getFunctionArity(node: t.Function): number {
   return count === -1 ? node.params.length : count;
 }
 
-const buildPropertyMethodAssignmentWrapper = template(`
+const buildPropertyMethodAssignmentWrapper = template.statement(`
   (function (FUNCTION_KEY) {
     function FUNCTION_ID() {
       return FUNCTION_KEY.apply(this, arguments);
@@ -40,7 +41,7 @@ const buildPropertyMethodAssignmentWrapper = template(`
   })(FUNCTION)
 `);
 
-const buildGeneratorPropertyMethodAssignmentWrapper = template(`
+const buildGeneratorPropertyMethodAssignmentWrapper = template.statement(`
   (function (FUNCTION_KEY) {
     function* FUNCTION_ID() {
       return yield* FUNCTION_KEY.apply(this, arguments);
@@ -54,8 +55,18 @@ const buildGeneratorPropertyMethodAssignmentWrapper = template(`
   })(FUNCTION)
 `);
 
-const visitor = {
-  "ReferencedIdentifier|BindingIdentifier"(path, state) {
+type State = {
+  name: string;
+  outerDeclar: t.Identifier;
+  selfAssignment: boolean;
+  selfReference: boolean;
+};
+
+const visitor: Visitor<State> = {
+  "ReferencedIdentifier|BindingIdentifier"(
+    path: NodePath<t.Identifier>,
+    state,
+  ) {
     // check if this node matches our function id
     if (path.node.name !== state.name) return;
 
@@ -69,7 +80,7 @@ const visitor = {
   },
 };
 
-function getNameFromLiteralId(id) {
+function getNameFromLiteralId(id: t.Literal) {
   if (isNullLiteral(id)) {
     return "null";
   }
@@ -89,7 +100,12 @@ function getNameFromLiteralId(id) {
   return "";
 }
 
-function wrap(state, method, id, scope) {
+function wrap(
+  state: State,
+  method: t.FunctionExpression | t.Class,
+  id: t.Identifier,
+  scope: Scope,
+) {
   if (state.selfReference) {
     if (scope.hasBinding(id.name) && !scope.hasGlobal(id.name)) {
       // we can just munge the local binding
@@ -131,12 +147,15 @@ function wrap(state, method, id, scope) {
   scope.getProgramParent().references[id.name] = true;
 }
 
-function visit(node, name, scope) {
-  const state = {
+function visit(
+  node: t.FunctionExpression | t.Class,
+  name: string,
+  scope: Scope,
+) {
+  const state: State = {
     selfAssignment: false,
     selfReference: false,
     outerDeclar: scope.getBindingIdentifier(name),
-    references: [],
     name: name,
   };
 
@@ -182,16 +201,21 @@ function visit(node, name, scope) {
  * @param {Boolean} localBinding whether a name could shadow a self-reference (e.g. converting arrow function)
  * @param {Boolean} supportUnicodeId whether a target support unicodeId or not
  */
-export default function (
+export default function <N extends t.FunctionExpression | t.Class>(
   {
     node,
     parent,
     scope,
     id,
-  }: { node: any; parent?: any; scope: any; id?: any },
+  }: {
+    node: N;
+    parent?: t.Node;
+    scope: Scope;
+    id?: t.LVal | t.StringLiteral | t.NumericLiteral | t.BigIntLiteral;
+  },
   localBinding = false,
   supportUnicodeId = false,
-) {
+): t.CallExpression | N {
   // has an `id` so we don't need to infer one
   if (node.id) return;
 
@@ -200,7 +224,11 @@ export default function (
     (!parent.computed || isLiteral(parent.key))
   ) {
     // { foo() {} };
-    id = parent.key;
+    id = parent.key as
+      | t.Identifier
+      | t.StringLiteral
+      | t.NumericLiteral
+      | t.BigIntLiteral;
   } else if (isVariableDeclarator(parent)) {
     // let foo = function () {};
     id = parent.id;
@@ -215,6 +243,7 @@ export default function (
       ) {
         // always going to reference this method
         node.id = cloneNode(id);
+        // @ts-expect-error Fixme: avoid mutating AST nodes
         node.id[NOT_LOCAL_BINDING] = true;
         return;
       }
@@ -242,13 +271,14 @@ export default function (
   }
 
   name = toBindingIdentifierName(name);
-  id = identifier(name);
+  const newId = identifier(name);
 
   // The id shouldn't be considered a local binding to the function because
   // we are simply trying to set the function name and not actually create
   // a local binding.
-  id[NOT_LOCAL_BINDING] = true;
+  // @ts-ignore Fixme: avoid mutating AST nodes
+  newId[NOT_LOCAL_BINDING] = true;
 
   const state = visit(node, name, scope);
-  return wrap(state, node, id, scope) || node;
+  return wrap(state, node, newId, scope) || node;
 }
diff --git a/packages/babel-helper-hoist-variables/src/index.ts b/packages/babel-helper-hoist-variables/src/index.ts
index 1cb3b8a3c4c5..89653ac33af8 100644
--- a/packages/babel-helper-hoist-variables/src/index.ts
+++ b/packages/babel-helper-hoist-variables/src/index.ts
@@ -4,7 +4,7 @@ import {
   identifier,
 } from "@babel/types";
 import type * as t from "@babel/types";
-import type { NodePath } from "@babel/traverse";
+import type { NodePath, Visitor } from "@babel/traverse";
 
 export type EmitFunction = (
   id: t.Identifier,
@@ -19,16 +19,16 @@ type State = {
 
 type Unpacked<T> = T extends (infer U)[] ? U : T;
 
-const visitor = {
-  Scope(path: NodePath, state: State) {
+const visitor: Visitor<State> = {
+  Scope(path, state) {
     if (state.kind === "let") path.skip();
   },
 
-  FunctionParent(path: NodePath) {
+  FunctionParent(path) {
     path.skip();
   },
 
-  VariableDeclaration(path: NodePath<t.VariableDeclaration>, state: State) {
+  VariableDeclaration(path, state) {
     if (state.kind && path.node.kind !== state.kind) return;
 
     const nodes = [];
diff --git a/packages/babel-helper-member-expression-to-functions/src/index.ts b/packages/babel-helper-member-expression-to-functions/src/index.ts
index fd629d54de30..efaf7293366c 100644
--- a/packages/babel-helper-member-expression-to-functions/src/index.ts
+++ b/packages/babel-helper-member-expression-to-functions/src/index.ts
@@ -25,7 +25,7 @@ import type * as t from "@babel/types";
 import { willPathCastToBoolean } from "./util";
 
 class AssignmentMemoiser {
-  private _map: WeakMap<t.Expression, { count: number; value: t.LVal }>;
+  private _map: WeakMap<t.Expression, { count: number; value: t.Identifier }>;
   constructor() {
     this._map = new WeakMap();
   }
@@ -49,7 +49,7 @@ class AssignmentMemoiser {
     return value;
   }
 
-  set(key: t.Expression, value: t.LVal, count: number) {
+  set(key: t.Expression, value: t.Identifier, count: number) {
     return this._map.set(key, { count, value });
   }
 }
@@ -66,11 +66,12 @@ function toNonOptional(
   if (path.isOptionalCallExpression()) {
     const callee = path.get("callee");
     if (path.node.optional && callee.isOptionalMemberExpression()) {
-      const { object } = callee.node;
-      const context = path.scope.maybeGenerateMemoised(object) || object;
+      // object must be a conditional expression because the optional private access in object has been transformed
+      const object = callee.node.object as t.ConditionalExpression;
+      const context = path.scope.maybeGenerateMemoised(object);
       callee
         .get("object")
-        .replaceWith(assignmentExpression("=", context as t.LVal, object));
+        .replaceWith(assignmentExpression("=", context, object));
 
       return callExpression(memberExpression(base, identifier("call")), [
         context,
@@ -95,7 +96,13 @@ function isInDetachedTree(path: NodePath) {
     const { parentPath, container, listKey } = path;
     const parentNode = parentPath.node;
     if (listKey) {
-      if (container !== parentNode[listKey]) return true;
+      if (
+        container !==
+        // @ts-expect-error listKey must be a valid parent node key
+        parentNode[listKey]
+      ) {
+        return true;
+      }
     } else {
       if (container !== parentNode) return true;
     }
@@ -208,10 +215,9 @@ const handle = {
         );
       }
 
-      const startingProp = startingOptional.isOptionalMemberExpression()
-        ? "object"
-        : "callee";
-      const startingNode = startingOptional.node[startingProp];
+      const startingNode = startingOptional.isOptionalMemberExpression()
+        ? startingOptional.node.object
+        : startingOptional.node.callee;
       const baseNeedsMemoised = scope.maybeGenerateMemoised(startingNode);
       const baseRef = baseNeedsMemoised ?? startingNode;
 
@@ -281,7 +287,12 @@ const handle = {
       }
 
       const baseMemoised = baseNeedsMemoised
-        ? assignmentExpression("=", cloneNode(baseRef), cloneNode(startingNode))
+        ? assignmentExpression(
+            "=",
+            // When base needs memoised, the baseRef must be an identifier
+            cloneNode(baseRef as t.Identifier),
+            cloneNode(startingNode),
+          )
         : cloneNode(baseRef);
 
       if (willEndPathCastToBoolean) {
diff --git a/packages/babel-helper-module-imports/src/import-builder.ts b/packages/babel-helper-module-imports/src/import-builder.ts
index 55c7d09c8cac..da78c1fcf3ca 100644
--- a/packages/babel-helper-module-imports/src/import-builder.ts
+++ b/packages/babel-helper-module-imports/src/import-builder.ts
@@ -13,20 +13,23 @@ import {
   variableDeclaration,
   variableDeclarator,
 } from "@babel/types";
+import type * as t from "@babel/types";
+import type { Scope } from "@babel/traverse";
+import type { File } from "@babel/core";
 
 /**
  * A class to track and accumulate mutations to the AST that will eventually
  * output a new require/import statement list.
  */
 export default class ImportBuilder {
-  _statements = [];
-  _resultName = null;
+  private _statements: t.Statement[] = [];
+  private _resultName: t.Identifier | t.MemberExpression = null;
 
-  _scope = null;
-  _hub = null;
-  private _importedSource: any;
+  declare _scope: Scope;
+  declare _hub: File["hub"];
+  private _importedSource: string;
 
-  constructor(importedSource, scope, hub) {
+  constructor(importedSource: string, scope: Scope, hub: File["hub"]) {
     this._scope = scope;
     this._hub = hub;
     this._importedSource = importedSource;
@@ -67,29 +70,29 @@ export default class ImportBuilder {
     this._resultName = cloneNode(local);
     return this;
   }
-  default(name) {
-    name = this._scope.generateUidIdentifier(name);
+  default(name: string) {
+    const id = this._scope.generateUidIdentifier(name);
     const statement = this._statements[this._statements.length - 1];
     assert(statement.type === "ImportDeclaration");
     assert(statement.specifiers.length === 0);
-    statement.specifiers = [importDefaultSpecifier(name)];
-    this._resultName = cloneNode(name);
+    statement.specifiers = [importDefaultSpecifier(id)];
+    this._resultName = cloneNode(id);
     return this;
   }
-  named(name, importName) {
+  named(name: string, importName: string) {
     if (importName === "default") return this.default(name);
 
-    name = this._scope.generateUidIdentifier(name);
+    const id = this._scope.generateUidIdentifier(name);
     const statement = this._statements[this._statements.length - 1];
     assert(statement.type === "ImportDeclaration");
     assert(statement.specifiers.length === 0);
-    statement.specifiers = [importSpecifier(name, identifier(importName))];
-    this._resultName = cloneNode(name);
+    statement.specifiers = [importSpecifier(id, identifier(importName))];
+    this._resultName = cloneNode(id);
     return this;
   }
 
-  var(name) {
-    name = this._scope.generateUidIdentifier(name);
+  var(name: string) {
+    const id = this._scope.generateUidIdentifier(name);
     let statement = this._statements[this._statements.length - 1];
     if (statement.type !== "ExpressionStatement") {
       assert(this._resultName);
@@ -97,9 +100,9 @@ export default class ImportBuilder {
       this._statements.push(statement);
     }
     this._statements[this._statements.length - 1] = variableDeclaration("var", [
-      variableDeclarator(name, statement.expression),
+      variableDeclarator(id, statement.expression),
     ]);
-    this._resultName = cloneNode(name);
+    this._resultName = cloneNode(id);
     return this;
   }
 
@@ -110,7 +113,7 @@ export default class ImportBuilder {
     return this._interop(this._hub.addHelper("interopRequireWildcard"));
   }
 
-  _interop(callee) {
+  _interop(callee: t.Expression) {
     const statement = this._statements[this._statements.length - 1];
     if (statement.type === "ExpressionStatement") {
       statement.expression = callExpression(callee, [statement.expression]);
@@ -125,7 +128,7 @@ export default class ImportBuilder {
     return this;
   }
 
-  prop(name) {
+  prop(name: string) {
     const statement = this._statements[this._statements.length - 1];
     if (statement.type === "ExpressionStatement") {
       statement.expression = memberExpression(
@@ -144,7 +147,7 @@ export default class ImportBuilder {
     return this;
   }
 
-  read(name) {
+  read(name: string) {
     this._resultName = memberExpression(this._resultName, identifier(name));
   }
 }
diff --git a/packages/babel-helper-module-imports/src/import-injector.ts b/packages/babel-helper-module-imports/src/import-injector.ts
index 2b1d78709795..7e439c44accd 100644
--- a/packages/babel-helper-module-imports/src/import-injector.ts
+++ b/packages/babel-helper-module-imports/src/import-injector.ts
@@ -1,7 +1,8 @@
 import assert from "assert";
 import { numericLiteral, sequenceExpression } from "@babel/types";
 import type * as t from "@babel/types";
-import type { NodePath, Scope, HubInterface } from "@babel/traverse";
+import type { NodePath, Scope } from "@babel/traverse";
+import type { File } from "@babel/core";
 
 import ImportBuilder from "./import-builder";
 import isModule from "./is-module";
@@ -93,8 +94,8 @@ export type ImportOptions = {
    */
   importPosition: "before" | "after";
 
-  nameHint?;
-  blockHoist?;
+  nameHint?: string;
+  blockHoist?: number;
 };
 
 /**
@@ -114,7 +115,7 @@ export default class ImportInjector {
   /**
    * The file used to inject helpers and resolve paths.
    */
-  declare _hub: HubInterface;
+  declare _hub: File["hub"];
 
   /**
    * The default options to use with this instance when imports are added.
@@ -129,21 +130,29 @@ export default class ImportInjector {
     importPosition: "before",
   };
 
-  constructor(path: NodePath, importedSource?, opts?) {
+  constructor(
+    path: NodePath,
+    importedSource?: string,
+    opts?: Partial<ImportOptions>,
+  ) {
     const programPath = path.find(p => p.isProgram()) as NodePath<t.Program>;
 
     this._programPath = programPath;
     this._programScope = programPath.scope;
-    this._hub = programPath.hub;
+    this._hub = programPath.hub as File["hub"];
 
     this._defaultOpts = this._applyDefaults(importedSource, opts, true);
   }
 
-  addDefault(importedSourceIn, opts) {
+  addDefault(importedSourceIn: string, opts: Partial<ImportOptions>) {
     return this.addNamed("default", importedSourceIn, opts);
   }
 
-  addNamed(importName, importedSourceIn, opts) {
+  addNamed(
+    importName: string,
+    importedSourceIn: string,
+    opts: Partial<ImportOptions>,
+  ) {
     assert(typeof importName === "string");
 
     return this._generateImport(
@@ -152,49 +161,44 @@ export default class ImportInjector {
     );
   }
 
-  addNamespace(importedSourceIn, opts) {
+  addNamespace(importedSourceIn: string, opts: Partial<ImportOptions>) {
     return this._generateImport(
       this._applyDefaults(importedSourceIn, opts),
       null,
     );
   }
 
-  addSideEffect(importedSourceIn, opts) {
+  addSideEffect(importedSourceIn: string, opts: Partial<ImportOptions>) {
     return this._generateImport(
       this._applyDefaults(importedSourceIn, opts),
-      false,
+      void 0,
     );
   }
 
-  _applyDefaults(importedSource, opts, isInit = false) {
-    const optsList = [];
+  _applyDefaults(
+    importedSource: string | Partial<ImportOptions>,
+    opts: Partial<ImportOptions> | undefined,
+    isInit = false,
+  ) {
+    let newOpts: ImportOptions;
     if (typeof importedSource === "string") {
-      optsList.push({ importedSource });
-      optsList.push(opts);
+      newOpts = { ...this._defaultOpts, importedSource, ...opts };
     } else {
       assert(!opts, "Unexpected secondary arguments.");
-
-      optsList.push(importedSource);
+      newOpts = { ...this._defaultOpts, ...importedSource };
     }
 
-    const newOpts: ImportOptions = {
-      ...this._defaultOpts,
-    };
-    for (const opts of optsList) {
-      if (!opts) continue;
-      Object.keys(newOpts).forEach(key => {
-        if (opts[key] !== undefined) newOpts[key] = opts[key];
-      });
-
-      if (!isInit) {
-        if (opts.nameHint !== undefined) newOpts.nameHint = opts.nameHint;
-        if (opts.blockHoist !== undefined) newOpts.blockHoist = opts.blockHoist;
-      }
+    if (!isInit && opts) {
+      if (opts.nameHint !== undefined) newOpts.nameHint = opts.nameHint;
+      if (opts.blockHoist !== undefined) newOpts.blockHoist = opts.blockHoist;
     }
     return newOpts;
   }
 
-  _generateImport(opts, importName) {
+  _generateImport(
+    opts: Partial<ImportOptions>,
+    importName: string | null | undefined,
+  ) {
     const isDefault = importName === "default";
     const isNamed = !!importName && !isDefault;
     const isNamespace = importName === null;
@@ -422,7 +426,11 @@ export default class ImportInjector {
     return resultName;
   }
 
-  _insertStatements(statements, importPosition = "before", blockHoist = 3) {
+  _insertStatements(
+    statements: t.Statement[],
+    importPosition = "before",
+    blockHoist = 3,
+  ) {
     const body = this._programPath.get("body");
 
     if (importPosition === "after") {
@@ -434,6 +442,7 @@ export default class ImportInjector {
       }
     } else {
       statements.forEach(node => {
+        // @ts-expect-error handle _blockHoist
         node._blockHoist = blockHoist;
       });
 
diff --git a/packages/babel-helper-module-imports/src/index.ts b/packages/babel-helper-module-imports/src/index.ts
index 44b98d5c2054..183aaabd6fe0 100644
--- a/packages/babel-helper-module-imports/src/index.ts
+++ b/packages/babel-helper-module-imports/src/index.ts
@@ -1,21 +1,77 @@
-import ImportInjector from "./import-injector";
+import ImportInjector, { type ImportOptions } from "./import-injector";
+import type { NodePath } from "@babel/traverse";
+import type * as t from "@babel/types";
 
 export { ImportInjector };
 
 export { default as isModule } from "./is-module";
 
-export function addDefault(path, importedSource, opts?) {
+export function addDefault(
+  path: NodePath,
+  importedSource: string,
+  opts?: Partial<ImportOptions>,
+) {
   return new ImportInjector(path).addDefault(importedSource, opts);
 }
 
-export function addNamed(path, name, importedSource, opts?) {
+function addNamed(
+  path: NodePath,
+  name: string,
+  importedSource: string,
+  opts?: Omit<
+    Partial<ImportOptions>,
+    "ensureLiveReference" | "ensureNoContext"
+  >,
+): t.Identifier;
+function addNamed(
+  path: NodePath,
+  name: string,
+  importedSource: string,
+  opts?: Omit<Partial<ImportOptions>, "ensureLiveReference"> & {
+    ensureLiveReference: true;
+  },
+): t.MemberExpression;
+function addNamed(
+  path: NodePath,
+  name: string,
+  importedSource: string,
+  opts?: Omit<Partial<ImportOptions>, "ensureNoContext"> & {
+    ensureNoContext: true;
+  },
+): t.SequenceExpression;
+/**
+ * add a named import to the program path of given path
+ *
+ * @export
+ * @param {NodePath} path The starting path to find a program path
+ * @param {string} name The name of the generated binding. Babel will prefix it with `_`
+ * @param {string} importedSource The source of the import
+ * @param {Partial<ImportOptions>} [opts]
+ * @returns {t.Identifier | t.MemberExpression | t.SequenceExpression} If opts.ensureNoContext is true, returns a SequenceExpression,
+ *   else if opts.ensureLiveReference is true, returns a MemberExpression, else returns an Identifier
+ */
+function addNamed(
+  path: NodePath,
+  name: string,
+  importedSource: string,
+  opts?: Partial<ImportOptions>,
+) {
   return new ImportInjector(path).addNamed(name, importedSource, opts);
 }
+export { addNamed };
 
-export function addNamespace(path, importedSource, opts?) {
+export function addNamespace(
+  path: NodePath,
+  importedSource: string,
+  opts?: Partial<ImportOptions>,
+) {
   return new ImportInjector(path).addNamespace(importedSource, opts);
 }
 
-export function addSideEffect(path, importedSource, opts?) {
+export function addSideEffect(
+  path: NodePath,
+  importedSource: string,
+  opts?: Partial<ImportOptions>,
+) {
   return new ImportInjector(path).addSideEffect(importedSource, opts);
 }
diff --git a/packages/babel-helper-module-transforms/src/index.ts b/packages/babel-helper-module-transforms/src/index.ts
index 5001699b619e..241dac12e110 100644
--- a/packages/babel-helper-module-transforms/src/index.ts
+++ b/packages/babel-helper-module-transforms/src/index.ts
@@ -27,7 +27,9 @@ import normalizeModuleAndLoadMetadata, {
   validateImportInteropOption,
 } from "./normalize-and-load-metadata";
 import type {
+  ImportInterop,
   InteropType,
+  Lazy,
   ModuleMetadata,
   SourceModuleMetadata,
 } from "./normalize-and-load-metadata";
@@ -38,6 +40,22 @@ export type { PluginOptions } from "./get-module-name";
 
 export { hasExports, isSideEffectImport, isModule, rewriteThis };
 
+export interface RewriteModuleStatementsAndPrepareHeaderOptions {
+  exportName?: string;
+  strict: boolean;
+  allowTopLevelThis?: boolean;
+  strictMode: boolean;
+  loose?: boolean;
+  importInterop?: ImportInterop;
+  noInterop?: boolean;
+  lazy?: Lazy;
+  esNamespaceOnly?: boolean;
+  filename: string | undefined;
+  constantReexports?: boolean | void;
+  enumerableModuleMeta?: boolean | void;
+  noIncompleteNsImportDetection?: boolean | void;
+}
+
 /**
  * Perform all of the generic ES6 module rewriting needed to handle initial
  * module processing. This function will rewrite the majority of the given
@@ -63,21 +81,7 @@ export function rewriteModuleStatementsAndPrepareHeader(
     constantReexports = loose,
     enumerableModuleMeta = loose,
     noIncompleteNsImportDetection,
-  }: {
-    exportName?;
-    strict;
-    allowTopLevelThis?;
-    strictMode;
-    loose?;
-    importInterop?: "none" | "babel" | "node";
-    noInterop?;
-    lazy?;
-    esNamespaceOnly?;
-    filename: string | undefined;
-    constantReexports?;
-    enumerableModuleMeta?;
-    noIncompleteNsImportDetection?: boolean;
-  },
+  }: RewriteModuleStatementsAndPrepareHeaderOptions,
 ) {
   validateImportInteropOption(importInterop);
   assert(isModule(path), "Cannot process module statements in a script");
@@ -138,9 +142,10 @@ export function rewriteModuleStatementsAndPrepareHeader(
  * Flag a set of statements as hoisted above all else so that module init
  * statements all run before user code.
  */
-export function ensureStatementsHoisted(statements) {
+export function ensureStatementsHoisted(statements: t.Statement[]) {
   // Force all of the header fields to be at the top of the file.
   statements.forEach(header => {
+    // @ts-ignore Fixme: handle _blockHoist property
     header._blockHoist = 3;
   });
 }
@@ -303,7 +308,7 @@ const buildReexportsFromMeta = (
  */
 function buildESModuleHeader(
   metadata: ModuleMetadata,
-  enumerableModuleMeta: boolean = false,
+  enumerableModuleMeta: boolean | void = false,
 ) {
   return (
     enumerableModuleMeta
@@ -321,7 +326,11 @@ function buildESModuleHeader(
 /**
  * Create a re-export initialization loop for a specific imported namespace.
  */
-function buildNamespaceReexport(metadata, namespace, constantReexports) {
+function buildNamespaceReexport(
+  metadata: ModuleMetadata,
+  namespace: t.Identifier | t.CallExpression,
+  constantReexports: boolean | void,
+) {
   return (
     constantReexports
       ? template.statement`
@@ -413,8 +422,8 @@ function buildExportNameListDeclaration(
 function buildExportInitializationStatements(
   programPath: NodePath,
   metadata: ModuleMetadata,
-  constantReexports: boolean = false,
-  noIncompleteNsImportDetection = false,
+  constantReexports: boolean | void = false,
+  noIncompleteNsImportDetection: boolean | void = false,
 ) {
   const initStatements: Array<[string, t.Statement | null]> = [];
 
@@ -514,7 +523,11 @@ const InitTemplate = {
   default: template.expression`EXPORTS.NAME = VALUE`,
 };
 
-function buildInitStatement(metadata: ModuleMetadata, exportNames, initExpr) {
+function buildInitStatement(
+  metadata: ModuleMetadata,
+  exportNames: string[],
+  initExpr: t.Expression,
+) {
   const { stringSpecifiers, exportName: EXPORTS } = metadata;
   return expressionStatement(
     exportNames.reduce((acc, exportName) => {
diff --git a/packages/babel-helper-module-transforms/src/normalize-and-load-metadata.ts b/packages/babel-helper-module-transforms/src/normalize-and-load-metadata.ts
index bd2941fba21f..b0793cfcd0f7 100644
--- a/packages/babel-helper-module-transforms/src/normalize-and-load-metadata.ts
+++ b/packages/babel-helper-module-transforms/src/normalize-and-load-metadata.ts
@@ -28,6 +28,14 @@ export type InteropType =
   | "node-namespace" // Node.js interop for namespace or default+named imports
   | "none"; // No interop, or named-only imports
 
+export type ImportInterop =
+  | "none"
+  | "babel"
+  | "node"
+  | ((source: string, filename?: string) => "none" | "babel" | "node");
+
+export type Lazy = boolean | string[] | ((source: string) => boolean);
+
 export interface SourceModuleMetadata {
   // A unique variable name to use for this namespace object. Centralized for simplicity.
   name: string;
@@ -45,7 +53,7 @@ export interface SourceModuleMetadata {
   reexportAll: null | {
     loc: t.SourceLocation | undefined | null;
   };
-  lazy?;
+  lazy?: Lazy;
 }
 
 export interface LocalExportMetadata {
@@ -75,7 +83,7 @@ export function isSideEffectImport(source: SourceModuleMetadata) {
 
 export function validateImportInteropOption(
   importInterop: any,
-): importInterop is "none" | "babel" | "node" | Function {
+): importInterop is ImportInterop {
   if (
     typeof importInterop !== "function" &&
     importInterop !== "none" &&
@@ -90,8 +98,8 @@ export function validateImportInteropOption(
 }
 
 function resolveImportInterop(
-  importInterop,
-  source,
+  importInterop: ImportInterop,
+  source: string,
   filename: string | undefined,
 ) {
   if (typeof importInterop === "function") {
@@ -113,6 +121,12 @@ export default function normalizeModuleAndLoadMetadata(
     lazy = false,
     esNamespaceOnly = false,
     filename,
+  }: {
+    importInterop: ImportInterop;
+    initializeReexports: boolean | void;
+    lazy: Lazy;
+    esNamespaceOnly: boolean;
+    filename: string;
   },
 ): ModuleMetadata {
   if (!exportName) {
@@ -219,8 +233,8 @@ function getModuleMetadata(
     initializeReexports,
   }: {
     // todo(flow-ts) changed from boolean, to match expected usage inside the function
-    lazy: boolean | string[] | Function;
-    initializeReexports: boolean;
+    lazy: boolean | string[] | ((source: string) => boolean);
+    initializeReexports: boolean | void;
   },
   stringSpecifiers: Set<string>,
 ) {
@@ -231,7 +245,7 @@ function getModuleMetadata(
   );
 
   const sourceData = new Map();
-  const getData = sourceNode => {
+  const getData = (sourceNode: t.StringLiteral) => {
     const source = sourceNode.value;
 
     let data = sourceData.get(source);
@@ -409,22 +423,26 @@ function getModuleMetadata(
   };
 }
 
+type ModuleBindingKind = "import" | "hoisted" | "block" | "var";
 /**
  * Get metadata about local variables that are exported.
  */
 function getLocalExportMetadata(
   programPath: NodePath<t.Program>,
-  initializeReexports: boolean,
+  initializeReexports: boolean | void,
   stringSpecifiers: Set<string>,
 ): Map<string, LocalExportMetadata> {
   const bindingKindLookup = new Map();
 
-  programPath.get("body").forEach((child: any) => {
-    let kind;
+  programPath.get("body").forEach(child => {
+    let kind: ModuleBindingKind;
     if (child.isImportDeclaration()) {
       kind = "import";
     } else {
-      if (child.isExportDefaultDeclaration()) child = child.get("declaration");
+      if (child.isExportDefaultDeclaration()) {
+        // @ts-ignore
+        child = child.get("declaration");
+      }
       if (child.isExportNamedDeclaration()) {
         if (child.node.declaration) {
           child = child.get("declaration");
@@ -460,7 +478,7 @@ function getLocalExportMetadata(
   });
 
   const localMetadata = new Map();
-  const getLocalMetadata = idPath => {
+  const getLocalMetadata = (idPath: NodePath<t.Identifier>) => {
     const localName = idPath.node.name;
     let metadata = localMetadata.get(localName);
 
@@ -562,7 +580,9 @@ function removeModuleDeclarations(programPath: NodePath<t.Program>) {
       ) {
         // @ts-expect-error todo(flow->ts): avoid mutations
         declaration._blockHoist = child.node._blockHoist;
-        child.replaceWith(declaration);
+        child.replaceWith(
+          declaration as NodePath<t.FunctionDeclaration | t.ClassDeclaration>,
+        );
       } else {
         // These should have been removed by the nameAnonymousExports() call.
         throw declaration.buildCodeFrameError(
diff --git a/packages/babel-helper-module-transforms/src/rewrite-live-references.ts b/packages/babel-helper-module-transforms/src/rewrite-live-references.ts
index 9ba5d3063182..33c7eb3af37b 100644
--- a/packages/babel-helper-module-transforms/src/rewrite-live-references.ts
+++ b/packages/babel-helper-module-transforms/src/rewrite-live-references.ts
@@ -27,12 +27,12 @@ import type { ModuleMetadata } from "./normalize-and-load-metadata";
 interface RewriteReferencesVisitorState {
   exported: Map<any, any>;
   metadata: ModuleMetadata;
-  requeueInParent: (path) => void;
+  requeueInParent: (path: NodePath) => void;
   scope: Scope;
   imported: Map<any, any>;
   buildImportReference: (
-    [source, importName, localName]: readonly [any, any, any],
-    identNode,
+    [source, importName, localName]: readonly [string, string, string],
+    identNode: t.Identifier | t.CallExpression | t.JSXIdentifier,
   ) => any;
   seen: WeakSet<object>;
 }
@@ -40,11 +40,11 @@ interface RewriteReferencesVisitorState {
 interface RewriteBindingInitVisitorState {
   exported: Map<any, any>;
   metadata: ModuleMetadata;
-  requeueInParent: (path) => void;
+  requeueInParent: (path: NodePath) => void;
   scope: Scope;
 }
 
-function isInType(path) {
+function isInType(path: NodePath) {
   do {
     switch (path.parent.type) {
       case "TSTypeAnnotation":
@@ -54,7 +54,13 @@ function isInType(path) {
       case "TypeAlias":
         return true;
       case "ExportSpecifier":
-        return path.parentPath.parent.exportKind === "type";
+        return (
+          (
+            path.parentPath.parent as
+              | t.ExportDefaultDeclaration
+              | t.ExportNamedDeclaration
+          ).exportKind === "type"
+        );
       default:
         if (path.parentPath.isStatement() || path.parentPath.isExpression()) {
           return false;
@@ -69,7 +75,7 @@ export default function rewriteLiveReferences(
 ) {
   const imported = new Map();
   const exported = new Map();
-  const requeueInParent = path => {
+  const requeueInParent = (path: NodePath) => {
     // Manually re-queue `exports.default =` expressions so that the ES3
     // transform has an opportunity to convert them. Ideally this would
     // happen automatically from the replaceWith above. See #4140 for
@@ -127,7 +133,13 @@ export default function rewriteLiveReferences(
       const meta = metadata.source.get(source);
 
       if (localName) {
-        if (meta.lazy) identNode = callExpression(identNode, []);
+        if (meta.lazy) {
+          identNode = callExpression(
+            // @ts-expect-error Fixme: we should handle the case when identNode is a JSXIdentifier
+            identNode,
+            [],
+          );
+        }
         return identNode;
       }
 
@@ -203,9 +215,9 @@ const rewriteBindingInitVisitor: Visitor<RewriteBindingInitVisitorState> = {
 };
 
 const buildBindingExportAssignmentExpression = (
-  metadata,
-  exportNames,
-  localExpr,
+  metadata: ModuleMetadata,
+  exportNames: string[],
+  localExpr: t.Expression,
 ) => {
   return (exportNames || []).reduce((expr, exportName) => {
     // class Foo {} export { Foo, Foo as Bar };
@@ -225,7 +237,7 @@ const buildBindingExportAssignmentExpression = (
   }, localExpr);
 };
 
-const buildImportThrow = localName => {
+const buildImportThrow = (localName: string) => {
   return template.expression.ast`
     (function() {
       throw new Error('"' + '${localName}' + '" is read-only.');
@@ -403,7 +415,7 @@ const rewriteReferencesVisitor: Visitor<RewriteReferencesVisitorState> = {
           const assignment = path.node;
 
           if (importData) {
-            assignment.left = buildImportReference(importData, assignment.left);
+            assignment.left = buildImportReference(importData, left.node);
 
             assignment.right = sequenceExpression([
               assignment.right,
@@ -437,7 +449,7 @@ const rewriteReferencesVisitor: Visitor<RewriteReferencesVisitorState> = {
 
         // Complex ({a, b, c} = {}); export { a, c };
         // =>   ({a, b, c} = {}), (exports.a = a, exports.c = c);
-        const items = [];
+        const items: t.Expression[] = [];
         programScopeIds.forEach(localName => {
           const exportedNames = exported.get(localName) || [];
           if (exportedNames.length > 0) {
diff --git a/packages/babel-helper-module-transforms/src/rewrite-this.ts b/packages/babel-helper-module-transforms/src/rewrite-this.ts
index 92d9dd233968..cfd6aa9c24a2 100644
--- a/packages/babel-helper-module-transforms/src/rewrite-this.ts
+++ b/packages/babel-helper-module-transforms/src/rewrite-this.ts
@@ -1,7 +1,6 @@
 import environmentVisitor from "@babel/helper-environment-visitor";
 import traverse from "@babel/traverse";
 import { numericLiteral, unaryExpression } from "@babel/types";
-import type * as t from "@babel/types";
 
 import type { NodePath, Visitor } from "@babel/traverse";
 export default function rewriteThis(programPath: NodePath) {
@@ -16,7 +15,7 @@ export default function rewriteThis(programPath: NodePath) {
 const rewriteThisVisitor: Visitor = traverse.visitors.merge([
   environmentVisitor,
   {
-    ThisExpression(path: NodePath<t.ThisExpression>) {
+    ThisExpression(path) {
       path.replaceWith(unaryExpression("void", numericLiteral(0), true));
     },
   },
diff --git a/packages/babel-helper-optimise-call-expression/src/index.ts b/packages/babel-helper-optimise-call-expression/src/index.ts
index 881aef8dd161..b0327d355b53 100644
--- a/packages/babel-helper-optimise-call-expression/src/index.ts
+++ b/packages/babel-helper-optimise-call-expression/src/index.ts
@@ -11,7 +11,6 @@ import type {
   CallExpression,
   Expression,
   OptionalCallExpression,
-  SpreadElement,
 } from "@babel/types";
 
 /**
@@ -21,14 +20,14 @@ import type {
  * @export
  * @param {Expression} callee The callee of call expression
  * @param {Expression} thisNode The desired this of call expression
- * @param {Readonly<Array<Expression | SpreadElement>>} args The arguments of call expression
+ * @param {Readonly<CallExpression["arguments"]>} args The arguments of call expression
  * @param {boolean} optional Whether the call expression is optional
  * @returns {CallExpression | OptionalCallExpression} The generated new call expression
  */
 export default function optimiseCallExpression(
   callee: Expression,
   thisNode: Expression,
-  args: Readonly<Array<Expression | SpreadElement>>,
+  args: Readonly<CallExpression["arguments"]>,
   optional: boolean,
 ): CallExpression | OptionalCallExpression {
   if (
diff --git a/packages/babel-helper-plugin-test-runner/src/index.ts b/packages/babel-helper-plugin-test-runner/src/index.ts
index 44e5a7d56f32..f5a43239e7a2 100644
--- a/packages/babel-helper-plugin-test-runner/src/index.ts
+++ b/packages/babel-helper-plugin-test-runner/src/index.ts
@@ -2,7 +2,7 @@ import testRunner from "@babel/helper-transform-fixture-test-runner";
 import path from "path";
 import { URL } from "url";
 
-export default function (loc) {
+export default function (loc: string) {
   if (!process.env.BABEL_8_BREAKING) {
     if (!loc.startsWith("file://")) {
       const name = path.basename(path.dirname(loc));
diff --git a/packages/babel-helper-plugin-utils/src/index.ts b/packages/babel-helper-plugin-utils/src/index.ts
index 96c4296b4a24..d1327b6bf0ce 100644
--- a/packages/babel-helper-plugin-utils/src/index.ts
+++ b/packages/babel-helper-plugin-utils/src/index.ts
@@ -19,13 +19,16 @@ export function declare<State = {}, Option = {}>(
 ) => PluginObject<State & PluginPass> {
   // @ts-ignore
   return (api, options: Option, dirname: string) => {
-    let clonedApi;
+    let clonedApi: PluginAPI;
 
-    for (const name of Object.keys(apiPolyfills)) {
+    for (const name of Object.keys(
+      apiPolyfills,
+    ) as (keyof typeof apiPolyfills)[]) {
       if (api[name]) continue;
 
       // TODO: Use ??= when flow lets us to do so
       clonedApi = clonedApi ?? copyApiObject(api);
+      // @ts-expect-error The shape of API polyfill is guaranteed by APIPolyfillFactory
       clonedApi[name] = apiPolyfills[name](clonedApi);
     }
 
@@ -38,11 +41,21 @@ export const declarePreset = declare as <Option = {}>(
   builder: (api: PresetAPI, options: Option, dirname: string) => PresetObject,
 ) => (api: PresetAPI, options: Option, dirname: string) => PresetObject;
 
-const apiPolyfills = {
+type APIPolyfillFactory<T extends keyof PluginAPI> = (
+  api: PluginAPI,
+) => PluginAPI[T];
+
+type APIPolyfills = {
+  assertVersion: APIPolyfillFactory<"assertVersion">;
+  targets: APIPolyfillFactory<"targets">;
+  assumption: APIPolyfillFactory<"assumption">;
+};
+
+const apiPolyfills: APIPolyfills = {
   // Not supported by Babel 7 and early versions of Babel 7 beta.
   // It's important that this is polyfilled for older Babel versions
   // since it's needed to report the version mismatch.
-  assertVersion: api => range => {
+  assertVersion: (api: PluginAPI) => (range: number | string) => {
     throwVersionError(range, api.version);
   },
   // This is supported starting from Babel 7.13
@@ -52,10 +65,12 @@ const apiPolyfills = {
   },
   // This is supported starting from Babel 7.13
   // TODO(Babel 8): Remove this polyfill
-  assumption: () => () => {},
+  assumption: () => () => {
+    return undefined;
+  },
 };
 
-function copyApiObject(api) {
+function copyApiObject(api: PluginAPI): PluginAPI {
   // Babel >= 7 <= beta.41 passed the API as a new object that had
   // babel/core as the prototype. While slightly faster, it also
   // means that the Object.assign copy below fails. Rather than
@@ -81,11 +96,11 @@ function copyApiObject(api) {
   };
 }
 
-function has(obj, key) {
+function has(obj: {}, key: string) {
   return Object.prototype.hasOwnProperty.call(obj, key);
 }
 
-function throwVersionError(range, version) {
+function throwVersionError(range: string | number, version: string) {
   if (typeof range === "number") {
     if (!Number.isInteger(range)) {
       throw new Error("Expected string or integer value.");
diff --git a/packages/babel-helper-remap-async-to-generator/src/index.ts b/packages/babel-helper-remap-async-to-generator/src/index.ts
index a4df21c8e60e..d15b95842791 100644
--- a/packages/babel-helper-remap-async-to-generator/src/index.ts
+++ b/packages/babel-helper-remap-async-to-generator/src/index.ts
@@ -1,6 +1,6 @@
 /* @noflow */
 
-import type { NodePath } from "@babel/traverse";
+import type { NodePath, Visitor } from "@babel/traverse";
 import wrapFunction from "@babel/helper-wrap-function";
 import annotateAsPure from "@babel/helper-annotate-as-pure";
 import {
@@ -10,8 +10,9 @@ import {
   isThisExpression,
   yieldExpression,
 } from "@babel/types";
+import type * as t from "@babel/types";
 
-const awaitVisitor = {
+const awaitVisitor: Visitor<{ wrapAwait: t.Expression }> = {
   Function(path) {
     path.skip();
   },
@@ -32,8 +33,8 @@ const awaitVisitor = {
 export default function (
   path: NodePath<any>,
   helpers: {
-    wrapAsync: any;
-    wrapAwait?: any;
+    wrapAsync: t.Expression;
+    wrapAwait?: t.Expression;
   },
   noNewArrows?: boolean,
   ignoreFunctionLength?: boolean,
diff --git a/packages/babel-helper-replace-supers/src/index.ts b/packages/babel-helper-replace-supers/src/index.ts
index bb0135a9ae6b..6bb6db81cd58 100644
--- a/packages/babel-helper-replace-supers/src/index.ts
+++ b/packages/babel-helper-replace-supers/src/index.ts
@@ -24,6 +24,12 @@ export {
   skipAllButComputedKey,
 } from "@babel/helper-environment-visitor";
 
+type ThisRef =
+  | {
+      memo: t.AssignmentExpression;
+      this: t.Identifier;
+    }
+  | { this: t.ThisExpression };
 /**
  * Creates an expression which result is the proto of objectRef.
  *
@@ -35,7 +41,12 @@ export {
  *
  *   helpers.getPrototypeOf(CLASS.prototype)
  */
-function getPrototypeOfExpression(objectRef, isStatic, file, isPrivateMethod) {
+function getPrototypeOfExpression(
+  objectRef: t.Identifier,
+  isStatic: boolean,
+  file: File,
+  isPrivateMethod: boolean,
+) {
   objectRef = cloneNode(objectRef);
   const targetRef =
     isStatic || isPrivateMethod
@@ -79,8 +90,8 @@ type SharedState = {
   isDerivedConstructor: boolean;
   isStatic: boolean;
   isPrivateMethod: boolean;
-  getObjectRef: Function;
-  getSuperRef: Function;
+  getObjectRef: () => t.Identifier;
+  getSuperRef: () => t.Identifier;
   // we dont need boundGet here, but memberExpressionToFunctions handler needs it.
   boundGet: HandlerState["get"];
 };
@@ -93,11 +104,25 @@ type SuperMember = NodePath<
     }
 >;
 
-const specHandlers = {
+interface SpecHandler
+  extends Pick<
+    Handler,
+    "get" | "set" | "destructureSet" | "call" | "optionalCall" | "memoise"
+  > {
+  _get(
+    this: Handler & SpecHandler,
+    superMember: SuperMember,
+    thisRefs: ThisRef,
+  ): t.CallExpression;
+  _getThisRefs(): ThisRef;
+  prop(this: Handler & SpecHandler, superMember: SuperMember): t.Expression;
+}
+
+const specHandlers: SpecHandler = {
   memoise(
-    this: Handler & typeof specHandlers,
+    this: Handler & SpecHandler,
     superMember: SuperMember,
-    count,
+    count: number,
   ) {
     const { scope, node } = superMember;
     const { computed, property } = node;
@@ -113,7 +138,7 @@ const specHandlers = {
     this.memoiser.set(property, memo, count);
   },
 
-  prop(this: Handler & typeof specHandlers, superMember: SuperMember) {
+  prop(this: Handler & SpecHandler, superMember: SuperMember) {
     const { computed, property } = superMember.node;
     if (this.memoiser.has(property)) {
       return cloneNode(this.memoiser.get(property));
@@ -126,14 +151,14 @@ const specHandlers = {
     return stringLiteral((property as t.Identifier).name);
   },
 
-  get(this: Handler & typeof specHandlers, superMember: SuperMember) {
+  get(this: Handler & SpecHandler, superMember: SuperMember) {
     return this._get(superMember, this._getThisRefs());
   },
 
   _get(
-    this: Handler & typeof specHandlers,
+    this: Handler & SpecHandler,
     superMember: SuperMember,
-    thisRefs,
+    thisRefs: ThisRef,
   ) {
     const proto = getPrototypeOfExpression(
       this.getObjectRef(),
@@ -142,13 +167,14 @@ const specHandlers = {
       this.isPrivateMethod,
     );
     return callExpression(this.file.addHelper("get"), [
+      // @ts-ignore memo does not exist when this.isDerivedConstructor is false
       thisRefs.memo ? sequenceExpression([thisRefs.memo, proto]) : proto,
       this.prop(superMember),
       thisRefs.this,
     ]);
   },
 
-  _getThisRefs(this: Handler & typeof specHandlers) {
+  _getThisRefs(this: Handler & SpecHandler): ThisRef {
     if (!this.isDerivedConstructor) {
       return { this: thisExpression() };
     }
@@ -159,7 +185,11 @@ const specHandlers = {
     };
   },
 
-  set(this: Handler & typeof specHandlers, superMember: SuperMember, value) {
+  set(
+    this: Handler & SpecHandler,
+    superMember: SuperMember,
+    value: t.Expression,
+  ) {
     const thisRefs = this._getThisRefs();
     const proto = getPrototypeOfExpression(
       this.getObjectRef(),
@@ -168,6 +198,7 @@ const specHandlers = {
       this.isPrivateMethod,
     );
     return callExpression(this.file.addHelper("set"), [
+      // @ts-ignore memo does not exist when this.isDerivedConstructor is false
       thisRefs.memo ? sequenceExpression([thisRefs.memo, proto]) : proto,
       this.prop(superMember),
       value,
@@ -176,16 +207,17 @@ const specHandlers = {
     ]);
   },
 
-  destructureSet(
-    this: Handler & typeof specHandlers,
-    superMember: SuperMember,
-  ) {
+  destructureSet(this: Handler & SpecHandler, superMember: SuperMember) {
     throw superMember.buildCodeFrameError(
       `Destructuring to a super field is not supported yet.`,
     );
   },
 
-  call(this: Handler & typeof specHandlers, superMember: SuperMember, args) {
+  call(
+    this: Handler & SpecHandler,
+    superMember: SuperMember,
+    args: t.CallExpression["arguments"],
+  ) {
     const thisRefs = this._getThisRefs();
     return optimiseCall(
       this._get(superMember, thisRefs),
@@ -196,9 +228,9 @@ const specHandlers = {
   },
 
   optionalCall(
-    this: Handler & typeof specHandlers,
+    this: Handler & SpecHandler,
     superMember: SuperMember,
-    args,
+    args: t.CallExpression["arguments"],
   ) {
     const thisRefs = this._getThisRefs();
     return optimiseCall(
@@ -242,7 +274,11 @@ const looseHandlers = {
     return memberExpression(object, prop, computed);
   },
 
-  set(this: Handler & typeof specHandlers, superMember: SuperMember, value) {
+  set(
+    this: Handler & typeof specHandlers,
+    superMember: SuperMember,
+    value: t.Expression,
+  ) {
     const { computed } = superMember.node;
     const prop = this.prop(superMember);
 
@@ -263,14 +299,18 @@ const looseHandlers = {
     return memberExpression(thisExpression(), prop, computed);
   },
 
-  call(this: Handler & typeof specHandlers, superMember: SuperMember, args) {
+  call(
+    this: Handler & typeof specHandlers,
+    superMember: SuperMember,
+    args: t.CallExpression["arguments"],
+  ) {
     return optimiseCall(this.get(superMember), thisExpression(), args, false);
   },
 
   optionalCall(
     this: Handler & typeof specHandlers,
     superMember: SuperMember,
-    args,
+    args: t.CallExpression["arguments"],
   ) {
     return optimiseCall(this.get(superMember), thisExpression(), args, true);
   },
diff --git a/packages/babel-helper-simple-access/src/index.ts b/packages/babel-helper-simple-access/src/index.ts
index 2b198edfd961..6e460c069b8b 100644
--- a/packages/babel-helper-simple-access/src/index.ts
+++ b/packages/babel-helper-simple-access/src/index.ts
@@ -20,7 +20,7 @@ type State = {
 };
 export default function simplifyAccess(
   path: NodePath,
-  bindingNames,
+  bindingNames: Set<string>,
   // TODO(Babel 8): Remove this
   includeUpdateExpression: boolean = true,
 ) {
diff --git a/packages/babel-helper-split-export-declaration/src/index.ts b/packages/babel-helper-split-export-declaration/src/index.ts
index 25ab91b6a9c1..24565980f95f 100644
--- a/packages/babel-helper-split-export-declaration/src/index.ts
+++ b/packages/babel-helper-split-export-declaration/src/index.ts
@@ -6,25 +6,33 @@ import {
   variableDeclaration,
   variableDeclarator,
 } from "@babel/types";
-
-export default function splitExportDeclaration(exportDeclaration) {
-  if (!exportDeclaration.isExportDeclaration()) {
-    throw new Error("Only export declarations can be split.");
+import type * as t from "@babel/types";
+import type { NodePath } from "@babel/traverse";
+
+export default function splitExportDeclaration(
+  exportDeclaration: NodePath<
+    t.ExportDefaultDeclaration | t.ExportNamedDeclaration
+  >,
+) {
+  if (
+    !exportDeclaration.isExportDeclaration() ||
+    exportDeclaration.isExportAllDeclaration()
+  ) {
+    throw new Error("Only default and named export declarations can be split.");
   }
 
   // build specifiers that point back to this export declaration
-  const isDefault = exportDeclaration.isExportDefaultDeclaration();
-  const declaration = exportDeclaration.get("declaration");
-  const isClassDeclaration = declaration.isClassDeclaration();
 
-  if (isDefault) {
+  if (exportDeclaration.isExportDefaultDeclaration()) {
+    const declaration = exportDeclaration.get("declaration");
     const standaloneDeclaration =
-      declaration.isFunctionDeclaration() || isClassDeclaration;
+      declaration.isFunctionDeclaration() || declaration.isClassDeclaration();
 
     const scope = declaration.isScope()
       ? declaration.scope.parent
       : declaration.scope;
 
+    // @ts-expect-error id is not defined in expressions other than function/class
     let id = declaration.node.id;
     let needBindingRegistration = false;
 
@@ -43,9 +51,13 @@ export default function splitExportDeclaration(exportDeclaration) {
     }
 
     const updatedDeclaration = standaloneDeclaration
-      ? declaration
+      ? declaration.node
       : variableDeclaration("var", [
-          variableDeclarator(cloneNode(id), declaration.node),
+          variableDeclarator(
+            cloneNode(id),
+            // @ts-expect-error When `standaloneDeclaration` is false, declaration must not be a Function/ClassDeclaration
+            declaration.node,
+          ),
         ]);
 
     const updatedExportDeclaration = exportNamedDeclaration(null, [
@@ -60,12 +72,14 @@ export default function splitExportDeclaration(exportDeclaration) {
     }
 
     return exportDeclaration;
-  }
-
-  if (exportDeclaration.get("specifiers").length > 0) {
+  } else if (
+    // @ts-expect-error TS can not narrow down to NodePath<t.ExportNamedDeclaration>
+    exportDeclaration.get("specifiers").length > 0
+  ) {
     throw new Error("It doesn't make sense to split exported specifiers.");
   }
 
+  const declaration = exportDeclaration.get("declaration");
   const bindingIdentifiers = declaration.getOuterBindingIdentifiers();
 
   const specifiers = Object.keys(bindingIdentifiers).map(name => {
diff --git a/packages/babel-helper-transform-fixture-test-runner/src/helpers.ts b/packages/babel-helper-transform-fixture-test-runner/src/helpers.ts
index 4df3ae81e847..7c15a524432e 100644
--- a/packages/babel-helper-transform-fixture-test-runner/src/helpers.ts
+++ b/packages/babel-helper-transform-fixture-test-runner/src/helpers.ts
@@ -1,7 +1,7 @@
-export function assertNoOwnProperties(obj) {
+export function assertNoOwnProperties(obj: {}) {
   expect(Object.getOwnPropertyNames(obj)).toHaveLength(0);
 }
 
-export function multiline(arr) {
+export function multiline(arr: string[]) {
   return arr.join("\n");
 }
diff --git a/packages/babel-helper-transform-fixture-test-runner/src/index.ts b/packages/babel-helper-transform-fixture-test-runner/src/index.ts
index 45c1f1b135cc..da82eadae3a9 100644
--- a/packages/babel-helper-transform-fixture-test-runner/src/index.ts
+++ b/packages/babel-helper-transform-fixture-test-runner/src/index.ts
@@ -1,9 +1,16 @@
 /* eslint-env jest */
 import * as babel from "@babel/core";
-import { buildExternalHelpers } from "@babel/core";
+import {
+  buildExternalHelpers,
+  type InputOptions,
+  type FileResult,
+} from "@babel/core";
 import {
   default as getFixtures,
   resolveOptionPluginOrPreset,
+  type Test,
+  type TestFile,
+  type TaskOptions,
 } from "@babel/helper-fixtures";
 import { codeFrameColumns } from "@babel/code-frame";
 import { TraceMap, originalPositionFor } from "@jridgewell/trace-mapping";
@@ -20,15 +27,22 @@ const require = createRequire(import.meta.url);
 
 import checkDuplicateNodes from "@babel/helper-check-duplicate-nodes";
 
+type Module = {
+  id: string;
+  exports: Record<string, unknown>;
+};
+
 if (!process.env.BABEL_8_BREAKING) {
-  // Introduced in Node.js 8
+  // Introduced in Node.js 10
   if (!assert.rejects) {
     assert.rejects = async function (block, validateError) {
       try {
-        await block();
+        await (typeof block === "function" ? block() : block);
         return Promise.reject(new Error("Promise not rejected"));
       } catch (error) {
-        if (!validateError(error)) {
+        // @ts-ignore Fixme: validateError can be a string | object
+        // see https://nodejs.org/api/assert.html#assertrejectsasyncfn-error-message
+        if (typeof validateError === "function" && !validateError(error)) {
           return Promise.reject(
             new Error("Promise rejected with invalid error"),
           );
@@ -51,14 +65,14 @@ const sharedTestContext = createContext();
 // babel.config.js file, so we disable config loading by
 // default. Tests can still set `configFile: true | string`
 // to re-enable config loading.
-function transformWithoutConfigFile(code, opts) {
+function transformWithoutConfigFile(code: string, opts: InputOptions) {
   return babel.transformSync(code, {
     configFile: false,
     babelrc: false,
     ...opts,
   });
 }
-function transformAsyncWithoutConfigFile(code, opts) {
+function transformAsyncWithoutConfigFile(code: string, opts: InputOptions) {
   return babel.transformAsync(code, {
     configFile: false,
     babelrc: false,
@@ -100,7 +114,7 @@ function runCacheableScriptInTestContext(
   srcFn: () => string,
   context: vm.Context,
   moduleCache: any,
-) {
+): Module {
   let cached = cachedScripts.get(filename);
   if (!cached) {
     const code = `(function (exports, require, module, __filename, __dirname) {\n${srcFn()}\n});`;
@@ -137,7 +151,8 @@ function runCacheableScriptInTestContext(
     id: filename,
     exports: {},
   };
-  const req = id => runModuleInTestContext(id, filename, context, moduleCache);
+  const req = (id: string) =>
+    runModuleInTestContext(id, filename, context, moduleCache);
   const dirname = path.dirname(filename);
 
   script
@@ -195,9 +210,10 @@ export function runCodeInTestContext(
   const filename = opts.filename;
   const dirname = path.dirname(filename);
   const moduleCache = contextModuleCache.get(context);
-  const req = id => runModuleInTestContext(id, filename, context, moduleCache);
+  const req = (id: string) =>
+    runModuleInTestContext(id, filename, context, moduleCache);
 
-  const module = {
+  const module: Module = {
     id: filename,
     exports: {},
   };
@@ -220,7 +236,7 @@ export function runCodeInTestContext(
   }
 }
 
-async function maybeMockConsole(validateLogs, run) {
+async function maybeMockConsole<R>(validateLogs: boolean, run: () => R) {
   const actualLogs = { stdout: "", stderr: "" };
 
   if (!validateLogs) return { result: await run(), actualLogs };
@@ -240,7 +256,7 @@ async function maybeMockConsole(validateLogs, run) {
   }
 }
 
-async function run(task) {
+async function run(task: Test) {
   const {
     actual,
     expect: expected,
@@ -255,7 +271,7 @@ async function run(task) {
   } = task;
 
   // todo(flow->ts) add proper return type (added any, because empty object is inferred)
-  function getOpts(self): any {
+  function getOpts(self: TestFile): any {
     const newOpts = {
       ast: true,
       cwd: path.dirname(self.loc),
@@ -273,7 +289,7 @@ async function run(task) {
   }
 
   let execCode = exec.code;
-  let result;
+  let result: FileResult;
   let resultExec;
 
   if (execCode) {
@@ -387,7 +403,11 @@ async function run(task) {
   }
 }
 
-function validateFile(actualCode, expectedLoc, expectedCode) {
+function validateFile(
+  actualCode: string,
+  expectedLoc: string,
+  expectedCode: string,
+) {
   try {
     expect(actualCode).toEqualFile({
       filename: expectedLoc,
@@ -401,11 +421,11 @@ function validateFile(actualCode, expectedLoc, expectedCode) {
   }
 }
 
-function escapeRegExp(string) {
+function escapeRegExp(string: string) {
   return string.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&");
 }
 
-function normalizeOutput(code, normalizePathSeparator?) {
+function normalizeOutput(code: string, normalizePathSeparator?: boolean) {
   const projectRoot = path.resolve(
     path.dirname(fileURLToPath(import.meta.url)),
     "../../../",
@@ -438,7 +458,7 @@ function normalizeOutput(code, normalizePathSeparator?) {
 }
 
 expect.extend({
-  toEqualFile(actual, { filename, code }) {
+  toEqualFile(actual, { filename, code }: Pick<TestFile, "filename" | "code">) {
     if (this.isNot) {
       throw new Error(".toEqualFile does not support negation");
     }
@@ -465,17 +485,25 @@ declare global {
   namespace jest {
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     interface Matchers<R> {
-      toEqualFile({ filename, code }): jest.CustomMatcherResult;
+      toEqualFile({
+        filename,
+        code,
+      }: Pick<TestFile, "filename" | "code">): jest.CustomMatcherResult;
     }
   }
 }
 
+export type SuiteOptions = {
+  ignoreSuites?: string[];
+  ignoreTasks?: string[];
+};
+
 export default function (
   fixturesLoc: string,
   name: string,
-  suiteOpts: any = {},
-  taskOpts: any = {},
-  dynamicOpts?: Function,
+  suiteOpts: SuiteOptions = {},
+  taskOpts: TaskOptions = {},
+  dynamicOpts?: (options: TaskOptions, task: Test) => void,
 ) {
   const suites = getFixtures(fixturesLoc);
 
@@ -508,12 +536,13 @@ export default function (
 
             if (dynamicOpts) dynamicOpts(task.options, task);
 
-            // @ts-expect-error todo(flow->ts) missing property
             if (task.externalHelpers) {
-              (task.options.plugins ??= []).push([
-                "external-helpers",
-                { helperVersion: EXTERNAL_HELPERS_VERSION },
-              ]);
+              (task.options.plugins ??= [])
+                // @ts-ignore manipulating input options
+                .push([
+                  "external-helpers",
+                  { helperVersion: EXTERNAL_HELPERS_VERSION },
+                ]);
             }
 
             const throwMsg = task.options.throws;
diff --git a/packages/babel-helper-validator-option/src/find-suggestion.ts b/packages/babel-helper-validator-option/src/find-suggestion.ts
index d418632ed307..3f34b24ffabd 100644
--- a/packages/babel-helper-validator-option/src/find-suggestion.ts
+++ b/packages/babel-helper-validator-option/src/find-suggestion.ts
@@ -9,7 +9,7 @@ const { min } = Math;
 // https://rosettacode.org/wiki/Levenshtein_distance#ES5
 function levenshtein(a: string, b: string): number {
   let t = [],
-    u = [],
+    u: number[] = [],
     i,
     j;
   const m = a.length,
diff --git a/packages/babel-helper-wrap-function/src/index.ts b/packages/babel-helper-wrap-function/src/index.ts
index d38f4dfca4a9..b02014eea6bb 100644
--- a/packages/babel-helper-wrap-function/src/index.ts
+++ b/packages/babel-helper-wrap-function/src/index.ts
@@ -30,7 +30,7 @@ const buildNamedExpressionWrapper = template.expression(`
   })()
 `);
 
-const buildDeclarationWrapper = template(`
+const buildDeclarationWrapper = template.statements(`
   function NAME(PARAMS) { return REF.apply(this, arguments); }
   function REF() {
     REF = FUNCTION;
@@ -109,8 +109,8 @@ function plainFunction(
   });
 
   if (isDeclaration) {
-    path.replaceWith(container[0]);
-    path.insertAfter(container[1]);
+    path.replaceWith((container as t.Statement[])[0]);
+    path.insertAfter((container as t.Statement[])[1]);
   } else {
     // @ts-expect-error todo(flow->ts) separate `wrapper` for `isDeclaration` and `else` branches
     const retFunction = container.callee.body.body[1].argument;
diff --git a/packages/babel-helpers/scripts/generate-helpers.js b/packages/babel-helpers/scripts/generate-helpers.js
index aadc9786f4d3..e0b37019320f 100644
--- a/packages/babel-helpers/scripts/generate-helpers.js
+++ b/packages/babel-helpers/scripts/generate-helpers.js
@@ -14,7 +14,7 @@ export default async function generateHelpers() {
 
 import template from "@babel/template";
 
-function helper(minVersion, source) {
+function helper(minVersion: string, source: string) {
   return Object.freeze({
     minVersion,
     ast: () => template.program.ast(source, { preserveComments: true }),
diff --git a/packages/babel-helpers/src/helpers-generated.ts b/packages/babel-helpers/src/helpers-generated.ts
index 0dc885248815..d40d731026b9 100644
--- a/packages/babel-helpers/src/helpers-generated.ts
+++ b/packages/babel-helpers/src/helpers-generated.ts
@@ -5,7 +5,7 @@
 
 import template from "@babel/template";
 
-function helper(minVersion, source) {
+function helper(minVersion: string, source: string) {
   return Object.freeze({
     minVersion,
     ast: () => template.program.ast(source, { preserveComments: true }),
diff --git a/packages/babel-highlight/src/index.ts b/packages/babel-highlight/src/index.ts
index 9ac6c0612d4e..60d2ee6bdb42 100644
--- a/packages/babel-highlight/src/index.ts
+++ b/packages/babel-highlight/src/index.ts
@@ -1,6 +1,6 @@
 /// <reference path="../../../lib/third-party-libs.d.ts" />
 
-import type { Token, JSXToken } from "js-tokens";
+import type { Token as JSToken, JSXToken } from "js-tokens";
 import jsTokens from "js-tokens";
 
 import {
@@ -33,6 +33,10 @@ type InternalTokenType =
   | "comment"
   | "invalid";
 
+type Token = {
+  type: InternalTokenType | "uncolored";
+  value: string;
+};
 /**
  * Chalk styles for token types.
  */
@@ -69,7 +73,7 @@ if (process.env.BABEL_8_BREAKING) {
    * Get the type of token, specifying punctuator type.
    */
   const getTokenType = function (
-    token: Token | JSXToken,
+    token: JSToken | JSXToken,
   ): InternalTokenType | "uncolored" {
     if (token.type === "IdentifierName") {
       if (
@@ -128,7 +132,7 @@ if (process.env.BABEL_8_BREAKING) {
   /**
    * Turn a string of JS into an array of objects.
    */
-  tokenize = function* (text: string) {
+  tokenize = function* (text: string): Generator<Token> {
     for (const token of jsTokens(text, { jsx: true })) {
       switch (token.type) {
         case "TemplateHead":
@@ -161,7 +165,9 @@ if (process.env.BABEL_8_BREAKING) {
    */
   const JSX_TAG = /^[a-z][\w-]*$/i;
 
-  const getTokenType = function (token, offset, text) {
+  // The token here is defined in js-tokens@4. However we don't bother
+  // typing it since the whole block will be removed in Babel 8
+  const getTokenType = function (token: any, offset: number, text: string) {
     if (token.type === "name") {
       if (
         isKeyword(token.value) ||
diff --git a/packages/babel-plugin-bugfix-v8-spread-parameters-in-optional-chaining/src/util.ts b/packages/babel-plugin-bugfix-v8-spread-parameters-in-optional-chaining/src/util.ts
index c813c79a7281..0c3f0863185c 100644
--- a/packages/babel-plugin-bugfix-v8-spread-parameters-in-optional-chaining/src/util.ts
+++ b/packages/babel-plugin-bugfix-v8-spread-parameters-in-optional-chaining/src/util.ts
@@ -6,7 +6,7 @@ import { types as t } from "@babel/core";
 // check if there is a spread element followed by another argument.
 // (...[], 0) or (...[], ...[])
 
-function matchAffectedArguments(argumentNodes) {
+function matchAffectedArguments(argumentNodes: t.CallExpression["arguments"]) {
   const spreadIndex = argumentNodes.findIndex(node => t.isSpreadElement(node));
   return spreadIndex >= 0 && spreadIndex !== argumentNodes.length - 1;
 }
diff --git a/packages/babel-plugin-external-helpers/src/index.ts b/packages/babel-plugin-external-helpers/src/index.ts
index 53da9423c4eb..c9f4b67f617f 100644
--- a/packages/babel-plugin-external-helpers/src/index.ts
+++ b/packages/babel-plugin-external-helpers/src/index.ts
@@ -25,7 +25,7 @@ export default declare((api, options: Options) => {
   return {
     name: "external-helpers",
     pre(file) {
-      file.set("helperGenerator", name => {
+      file.set("helperGenerator", (name: string) => {
         // If the helper didn't exist yet at the version given, we bail
         // out and let Babel either insert it directly, or throw an error
         // so that plugins can handle that case properly.
diff --git a/packages/babel-plugin-proposal-async-generator-functions/src/for-await.ts b/packages/babel-plugin-proposal-async-generator-functions/src/for-await.ts
index c3df45b3f604..fce810c5e9bc 100644
--- a/packages/babel-plugin-proposal-async-generator-functions/src/for-await.ts
+++ b/packages/babel-plugin-proposal-async-generator-functions/src/for-await.ts
@@ -1,4 +1,5 @@
 import { types as t, template } from "@babel/core";
+import type { NodePath } from "@babel/traverse";
 
 const buildForAwait = template(`
   async function wrapper() {
@@ -29,7 +30,10 @@ const buildForAwait = template(`
   }
 `);
 
-export default function (path, { getAsyncIterator }) {
+export default function (
+  path: NodePath<t.ForOfStatement>,
+  { getAsyncIterator }: { getAsyncIterator: t.Identifier },
+) {
   const { node, scope, parent } = path;
 
   const stepKey = scope.generateUidIdentifier("step");
diff --git a/packages/babel-plugin-proposal-async-generator-functions/src/index.ts b/packages/babel-plugin-proposal-async-generator-functions/src/index.ts
index 717f7ec18b96..b9cc7734baf2 100644
--- a/packages/babel-plugin-proposal-async-generator-functions/src/index.ts
+++ b/packages/babel-plugin-proposal-async-generator-functions/src/index.ts
@@ -3,7 +3,7 @@ import remapAsyncToGenerator from "@babel/helper-remap-async-to-generator";
 import syntaxAsyncGenerators from "@babel/plugin-syntax-async-generators";
 import { types as t } from "@babel/core";
 import type { PluginPass } from "@babel/core";
-import type { Visitor } from "@babel/traverse";
+import type { NodePath, Visitor } from "@babel/traverse";
 import rewriteForAwait from "./for-await";
 
 export default declare(api => {
@@ -29,7 +29,7 @@ export default declare(api => {
       path.skip();
     },
 
-    ForOfStatement(path, { file }) {
+    ForOfStatement(path: NodePath<t.ForOfStatement>, { file }) {
       const { node } = path;
       if (!node.await) return;
 
@@ -49,7 +49,7 @@ export default declare(api => {
       }
 
       // push the rest of the original loop body onto our new body
-      block.body.push(...(node.body as t.BlockStatement).body);
+      block.body.push(...path.node.body.body);
 
       t.inherits(loop, node);
       t.inherits(loop.body, node.body);
diff --git a/packages/babel-plugin-proposal-class-static-block/src/index.ts b/packages/babel-plugin-proposal-class-static-block/src/index.ts
index a31a0288c078..ed596bd04468 100644
--- a/packages/babel-plugin-proposal-class-static-block/src/index.ts
+++ b/packages/babel-plugin-proposal-class-static-block/src/index.ts
@@ -1,5 +1,6 @@
 import { declare } from "@babel/helper-plugin-utils";
 import syntaxClassStaticBlock from "@babel/plugin-syntax-class-static-block";
+import type { Scope } from "@babel/traverse";
 
 import {
   enableFeature,
@@ -10,11 +11,11 @@ import type * as t from "@babel/types";
 /**
  * Generate a uid that is not in `denyList`
  *
- * @param {*} scope
+ * @param {Scope} scope
  * @param {Set<string>} denyList a deny list that the generated uid should avoid
  * @returns
  */
-function generateUid(scope, denyList: Set<string>) {
+function generateUid(scope: Scope, denyList: Set<string>) {
   const name = "";
   let uid;
   let i = 1;
diff --git a/packages/babel-plugin-proposal-decorators/package.json b/packages/babel-plugin-proposal-decorators/package.json
index 1755430d5a2d..4e46524592c1 100644
--- a/packages/babel-plugin-proposal-decorators/package.json
+++ b/packages/babel-plugin-proposal-decorators/package.json
@@ -24,8 +24,7 @@
     "@babel/helper-plugin-utils": "workspace:^",
     "@babel/helper-replace-supers": "workspace:^",
     "@babel/helper-split-export-declaration": "workspace:^",
-    "@babel/plugin-syntax-decorators": "workspace:^",
-    "charcodes": "^0.2.0"
+    "@babel/plugin-syntax-decorators": "workspace:^"
   },
   "peerDependencies": {
     "@babel/core": "^7.0.0-0"
@@ -34,7 +33,9 @@
     "@babel/core": "workspace:^",
     "@babel/helper-plugin-test-runner": "workspace:^",
     "@babel/traverse": "workspace:^",
+    "@types/charcodes": "^0.2.0",
     "babel-plugin-polyfill-es-shims": "^0.6.1",
+    "charcodes": "^0.2.0",
     "object.getownpropertydescriptors": "^2.1.1"
   },
   "engines": {
diff --git a/packages/babel-plugin-proposal-decorators/src/index.ts b/packages/babel-plugin-proposal-decorators/src/index.ts
index 6030513abdde..929fd5e824a2 100644
--- a/packages/babel-plugin-proposal-decorators/src/index.ts
+++ b/packages/babel-plugin-proposal-decorators/src/index.ts
@@ -8,7 +8,13 @@ import {
 } from "@babel/helper-create-class-features-plugin";
 import legacyVisitor from "./transformer-legacy";
 import transformer2021_12 from "./transformer-2021-12";
-import type { Options } from "@babel/plugin-syntax-decorators";
+import type { Options as SyntaxOptions } from "@babel/plugin-syntax-decorators";
+
+interface Options extends SyntaxOptions {
+  /** @depreated use `constantSuper` assumption instead. Only supported in 2021-12 version. */
+  loose?: boolean;
+}
+
 export type { Options };
 
 export default declare((api, options: Options) => {
diff --git a/packages/babel-plugin-proposal-decorators/src/transformer-2021-12.ts b/packages/babel-plugin-proposal-decorators/src/transformer-2021-12.ts
index 7072a6baa289..10af52865a2f 100644
--- a/packages/babel-plugin-proposal-decorators/src/transformer-2021-12.ts
+++ b/packages/babel-plugin-proposal-decorators/src/transformer-2021-12.ts
@@ -5,7 +5,7 @@ import ReplaceSupers from "@babel/helper-replace-supers";
 import splitExportDeclaration from "@babel/helper-split-export-declaration";
 import * as charCodes from "charcodes";
 import type { PluginAPI, PluginObject, PluginPass } from "@babel/core";
-import type { Options } from "..";
+import type { Options } from "./index";
 
 type ClassDecoratableElement =
   | t.ClassMethod
@@ -52,7 +52,7 @@ function incrementId(id: number[], idx = id.length - 1): void {
 function createPrivateUidGeneratorForClass(
   classPath: NodePath<t.ClassDeclaration | t.ClassExpression>,
 ): () => t.PrivateName {
-  const currentPrivateId = [];
+  const currentPrivateId: number[] = [];
   const privateNames = new Set<string>();
 
   classPath.traverse({
@@ -143,7 +143,10 @@ function replaceClassWithVar(
       t.sequenceExpression([newClassExpr, varId]),
     );
 
-    return [t.cloneNode(varId), newPath.get("expressions.0")];
+    return [
+      t.cloneNode(varId),
+      newPath.get("expressions.0") as NodePath<t.ClassExpression>,
+    ];
   }
 }
 
@@ -888,7 +891,11 @@ function transformClass(
 
   if (classDecorators) {
     locals.push(classLocal, classInitLocal);
-    const statics = [];
+    const statics: (
+      | t.ClassProperty
+      | t.ClassPrivateProperty
+      | t.ClassPrivateMethod
+    )[] = [];
     let staticBlocks: t.StaticBlock[] = [];
     path.get("body.body").forEach(element => {
       // Static blocks cannot be compiled to "instance blocks", but we can inline
diff --git a/packages/babel-plugin-proposal-decorators/src/transformer-legacy.ts b/packages/babel-plugin-proposal-decorators/src/transformer-legacy.ts
index ca16608bbb4a..586793653290 100644
--- a/packages/babel-plugin-proposal-decorators/src/transformer-legacy.ts
+++ b/packages/babel-plugin-proposal-decorators/src/transformer-legacy.ts
@@ -1,19 +1,26 @@
 // Fork of https://github.com/loganfsmyth/babel-plugin-proposal-decorators-legacy
 
-import { template, types as t } from "@babel/core";
-import type { Visitor } from "@babel/traverse";
+import { template, types as t, type PluginPass } from "@babel/core";
+import type { NodePath, Visitor } from "@babel/traverse";
 
-const buildClassDecorator = template(`
+const buildClassDecorator = template.statement(`
   DECORATOR(CLASS_REF = INNER) || CLASS_REF;
-`) as (replacements: { DECORATOR; CLASS_REF; INNER }) => t.ExpressionStatement;
+`) as (replacements: {
+  DECORATOR: t.Expression;
+  CLASS_REF: t.Identifier;
+  INNER: t.Expression;
+}) => t.ExpressionStatement;
 
 const buildClassPrototype = template(`
   CLASS_REF.prototype;
-`) as (replacements: { CLASS_REF }) => t.ExpressionStatement;
+`) as (replacements: { CLASS_REF: t.Identifier }) => t.ExpressionStatement;
 
 const buildGetDescriptor = template(`
     Object.getOwnPropertyDescriptor(TARGET, PROPERTY);
-`) as (replacements: { TARGET; PROPERTY }) => t.ExpressionStatement;
+`) as (replacements: {
+  TARGET: t.Expression;
+  PROPERTY: t.Literal;
+}) => t.ExpressionStatement;
 
 const buildGetObjectInitializer = template(`
     (TEMP = Object.getOwnPropertyDescriptor(TARGET, PROPERTY), (TEMP = TEMP ? TEMP.value : undefined), {
@@ -24,21 +31,45 @@ const buildGetObjectInitializer = template(`
             return TEMP;
         }
     })
-`) as (replacements: { TEMP; TARGET; PROPERTY }) => t.ExpressionStatement;
+`) as (replacements: {
+  TEMP: t.Identifier;
+  TARGET: t.Expression;
+  PROPERTY: t.Literal;
+}) => t.ExpressionStatement;
 
 const WARNING_CALLS = new WeakSet();
 
+// legacy decorator does not support ClassAccessorProperty
+type ClassDecoratableElement =
+  | t.ClassMethod
+  | t.ClassPrivateMethod
+  | t.ClassProperty
+  | t.ClassPrivateProperty;
+
 /**
  * If the decorator expressions are non-identifiers, hoist them to before the class so we can be sure
  * that they are evaluated in order.
  */
-function applyEnsureOrdering(path) {
+function applyEnsureOrdering(
+  path: NodePath<t.ClassExpression | t.ObjectExpression>,
+) {
   // TODO: This should probably also hoist computed properties.
-  const decorators = (
+  const decorators: t.Decorator[] = (
     path.isClass()
-      ? [path].concat(path.get("body.body"))
+      ? [
+          path,
+          ...(path.get("body.body") as NodePath<ClassDecoratableElement>[]),
+        ]
       : path.get("properties")
-  ).reduce((acc, prop) => acc.concat(prop.node.decorators || []), []);
+  ).reduce(
+    (
+      acc: t.Decorator[],
+      prop: NodePath<
+        t.ObjectMember | t.ClassExpression | ClassDecoratableElement
+      >,
+    ) => acc.concat(prop.node.decorators || []),
+    [],
+  );
 
   const identDecorators = decorators.filter(
     decorator => !t.isIdentifier(decorator.expression),
@@ -47,7 +78,7 @@ function applyEnsureOrdering(path) {
 
   return t.sequenceExpression(
     identDecorators
-      .map(decorator => {
+      .map((decorator): t.Expression => {
         const expression = decorator.expression;
         const id = (decorator.expression =
           path.scope.generateDeclaredUidIdentifier("dec"));
@@ -61,7 +92,7 @@ function applyEnsureOrdering(path) {
  * Given a class expression with class-level decorators, create a new expression
  * with the proper decorated behavior.
  */
-function applyClassDecorators(classPath) {
+function applyClassDecorators(classPath: NodePath<t.ClassExpression>) {
   if (!hasClassDecorators(classPath.node)) return;
 
   const decorators = classPath.node.decorators || [];
@@ -81,7 +112,7 @@ function applyClassDecorators(classPath) {
     }, classPath.node);
 }
 
-function hasClassDecorators(classNode) {
+function hasClassDecorators(classNode: t.Class) {
   return !!(classNode.decorators && classNode.decorators.length);
 }
 
@@ -89,52 +120,88 @@ function hasClassDecorators(classNode) {
  * Given a class expression with method-level decorators, create a new expression
  * with the proper decorated behavior.
  */
-function applyMethodDecorators(path, state) {
+function applyMethodDecorators(
+  path: NodePath<t.ClassExpression>,
+  state: PluginPass,
+) {
   if (!hasMethodDecorators(path.node.body.body)) return;
 
-  return applyTargetDecorators(path, state, path.node.body.body);
+  return applyTargetDecorators(
+    path,
+    state,
+    // @ts-expect-error ClassAccessorProperty is not supported in legacy decorator
+    path.node.body.body,
+  );
 }
 
-function hasMethodDecorators(body) {
-  return body.some(node => node.decorators?.length);
+function hasMethodDecorators(
+  body: t.ClassBody["body"] | t.ObjectExpression["properties"],
+) {
+  return body.some(
+    node =>
+      // @ts-expect-error decorators not in SpreadElement/StaticBlock
+      node.decorators?.length,
+  );
 }
 
 /**
  * Given an object expression with property decorators, create a new expression
  * with the proper decorated behavior.
  */
-function applyObjectDecorators(path, state) {
+function applyObjectDecorators(
+  path: NodePath<t.ObjectExpression>,
+  state: PluginPass,
+) {
   if (!hasMethodDecorators(path.node.properties)) return;
 
-  return applyTargetDecorators(path, state, path.node.properties);
+  return applyTargetDecorators(
+    path,
+    state,
+    path.node.properties.filter(
+      (prop): prop is t.ObjectMember => prop.type !== "SpreadElement",
+    ),
+  );
 }
 
 /**
  * A helper to pull out property decorators into a sequence expression.
  */
-function applyTargetDecorators(path, state, decoratedProps) {
+function applyTargetDecorators(
+  path: NodePath<t.ClassExpression | t.ObjectExpression>,
+  state: PluginPass,
+  decoratedProps: (t.ObjectMember | ClassDecoratableElement)[],
+) {
   const name = path.scope.generateDeclaredUidIdentifier(
     path.isClass() ? "class" : "obj",
   );
 
   const exprs = decoratedProps.reduce(function (acc, node) {
-    const decorators = node.decorators || [];
-    node.decorators = null;
+    let decorators: t.Decorator[] = [];
+    if (node.decorators != null) {
+      decorators = node.decorators;
+      node.decorators = null;
+    }
 
     if (decorators.length === 0) return acc;
 
-    if (node.computed) {
+    if (
+      // @ts-expect-error computed is not in ClassPrivateProperty
+      node.computed
+    ) {
       throw path.buildCodeFrameError(
         "Computed method/property decorators are not yet supported.",
       );
     }
 
-    const property = t.isLiteral(node.key)
+    const property: t.Literal = t.isLiteral(node.key)
       ? node.key
-      : t.stringLiteral(node.key.name);
+      : t.stringLiteral(
+          // @ts-expect-error: should we handle ClassPrivateProperty?
+          node.key.name,
+        );
 
     const target =
-      path.isClass() && !node.static
+      path.isClass() && !(node as ClassDecoratableElement).static
         ? buildClassPrototype({
             CLASS_REF: name,
           }).expression
@@ -217,7 +284,7 @@ function applyTargetDecorators(path, state, decoratedProps) {
   ]);
 }
 
-function decoratedClassToExpression({ node, scope }) {
+function decoratedClassToExpression({ node, scope }: NodePath<t.Class>) {
   if (!hasClassDecorators(node) && !hasMethodDecorators(node.body.body)) {
     return;
   }
@@ -231,7 +298,7 @@ function decoratedClassToExpression({ node, scope }) {
   ]);
 }
 
-export default {
+const visitor: Visitor<PluginPass> = {
   ExportDefaultDeclaration(path) {
     const decl = path.get("declaration");
     if (!decl.isClassDeclaration()) return;
@@ -320,4 +387,6 @@ export default {
       ]),
     );
   },
-} as Visitor<any>;
+};
+
+export default visitor;
diff --git a/packages/babel-plugin-proposal-destructuring-private/src/index.ts b/packages/babel-plugin-proposal-destructuring-private/src/index.ts
index f210f5146e52..b4fda77cc40f 100644
--- a/packages/babel-plugin-proposal-destructuring-private/src/index.ts
+++ b/packages/babel-plugin-proposal-destructuring-private/src/index.ts
@@ -10,7 +10,8 @@ import { convertFunctionParams } from "@babel/plugin-transform-parameters";
 import { unshiftForXStatementBody } from "@babel/plugin-transform-destructuring";
 
 import type { PluginPass } from "@babel/core";
-import type { Visitor } from "@babel/traverse";
+import type { NodePath, Visitor } from "@babel/traverse";
+import type * as t from "@babel/types";
 
 export default declare(function ({ assertVersion, assumption, types: t }) {
   assertVersion("^7.17.0");
@@ -40,7 +41,7 @@ export default declare(function ({ assertVersion, assumption, types: t }) {
       );
       if (firstPrivateIndex === -1) return;
       // wrap function body within IIFE if any param is shadowed
-      convertFunctionParams(path, ignoreFunctionLength, () => false, false);
+      convertFunctionParams(path, ignoreFunctionLength, () => false);
       // invariant: path.body is always a BlockStatement after `convertFunctionParams`
       const { node, scope } = path;
       const { params } = node;
@@ -51,7 +52,10 @@ export default declare(function ({ assertVersion, assumption, types: t }) {
       const { params: transformedParams, variableDeclaration } =
         buildVariableDeclarationFromParams(paramsAfterIndex, scope);
 
-      path.get("body").unshiftContainer("body", variableDeclaration);
+      (path.get("body") as NodePath<t.BlockStatement>).unshiftContainer(
+        "body",
+        variableDeclaration,
+      );
       params.push(...transformedParams);
       // preserve function.length
       // (b, p1) => {}
diff --git a/packages/babel-plugin-proposal-destructuring-private/src/util.ts b/packages/babel-plugin-proposal-destructuring-private/src/util.ts
index 66ffbba18b53..bf755585f3f8 100644
--- a/packages/babel-plugin-proposal-destructuring-private/src/util.ts
+++ b/packages/babel-plugin-proposal-destructuring-private/src/util.ts
@@ -117,7 +117,7 @@ function buildAssignmentsFromPatternList(
   transformed: Transformed[];
 } {
   const newElements: (t.Identifier | t.RestElement)[] = [],
-    transformed = [];
+    transformed: Transformed[] = [];
   for (let element of elements) {
     if (element === null) {
       newElements.push(null);
@@ -142,7 +142,7 @@ function buildAssignmentsFromPatternList(
       });
     } else {
       transformed.push({
-        left: element,
+        left: element as Transformed["left"],
         right: cloneNode(tempId),
       });
     }
@@ -150,6 +150,12 @@ function buildAssignmentsFromPatternList(
   return { elements: newElements, transformed };
 }
 
+type StackItem = {
+  node: t.LVal | t.ObjectProperty | null;
+  index: number;
+  depth: number;
+};
+
 /**
  * A DFS simplified pattern traverser. It skips computed property keys and assignment pattern
  * initializers. The following nodes will be delegated to the visitor:
@@ -170,13 +176,9 @@ export function* traversePattern(
     depth: number,
   ) => Generator<any, void, any>,
 ) {
-  const stack = [];
+  const stack: StackItem[] = [];
   stack.push({ node: root, index: 0, depth: 0 });
-  let item: {
-    node: t.LVal | t.ObjectProperty | null;
-    index: number;
-    depth: number;
-  };
+  let item: StackItem;
   while ((item = stack.pop()) !== undefined) {
     const { node, index } = item;
     if (node === null) continue;
@@ -188,7 +190,7 @@ export function* traversePattern(
         break;
       case "ObjectProperty":
         // inherit the depth and index as an object property can not be an LHS without object pattern
-        stack.push({ node: node.value, index, depth: item.depth });
+        stack.push({ node: node.value as t.LVal, index, depth: item.depth });
         break;
       case "RestElement":
         stack.push({ node: node.argument, index: 0, depth });
@@ -250,7 +252,7 @@ export function hasPrivateClassElement(node: t.ClassBody): boolean {
  * @param {t.LVal} pattern
  */
 export function* privateKeyPathIterator(pattern: t.LVal) {
-  const indexPath = [];
+  const indexPath: number[] = [];
   yield* traversePattern(pattern, function* (node, index, depth) {
     indexPath[depth] = index;
     if (isObjectProperty(node) && isPrivateName(node.key)) {
diff --git a/packages/babel-plugin-proposal-function-bind/src/index.ts b/packages/babel-plugin-proposal-function-bind/src/index.ts
index 4a26c705cf2f..739317a08ae5 100644
--- a/packages/babel-plugin-proposal-function-bind/src/index.ts
+++ b/packages/babel-plugin-proposal-function-bind/src/index.ts
@@ -1,11 +1,12 @@
 import { declare } from "@babel/helper-plugin-utils";
 import syntaxFunctionBind from "@babel/plugin-syntax-function-bind";
 import { types as t } from "@babel/core";
+import type { Scope } from "@babel/traverse";
 
 export default declare(api => {
   api.assertVersion(7);
 
-  function getTempId(scope) {
+  function getTempId(scope: Scope) {
     let id = scope.path.getData("functionBind");
     if (id) return t.cloneNode(id);
 
@@ -13,15 +14,18 @@ export default declare(api => {
     return scope.path.setData("functionBind", id);
   }
 
-  function getStaticContext(bind, scope) {
-    const object = bind.object || bind.callee.object;
+  function getStaticContext(bind: t.BindExpression, scope: Scope) {
+    const object =
+      bind.object ||
+      // @ts-ignore Fixme: should check bind.callee type first
+      bind.callee.object;
     return (
       scope.isStatic(object) &&
       (t.isSuper(object) ? t.thisExpression() : object)
     );
   }
 
-  function inferBindContext(bind, scope) {
+  function inferBindContext(bind: t.BindExpression, scope: Scope) {
     const staticContext = getStaticContext(bind, scope);
     if (staticContext) return t.cloneNode(staticContext);
 
@@ -32,9 +36,11 @@ export default declare(api => {
         bind.callee,
       ]);
     } else {
+      // @ts-ignore Fixme: should check bind.callee type first
       bind.callee.object = t.assignmentExpression(
         "=",
         tempId,
+        // @ts-ignore Fixme: should check bind.callee type first
         bind.callee.object,
       );
     }
diff --git a/packages/babel-plugin-proposal-function-sent/src/index.ts b/packages/babel-plugin-proposal-function-sent/src/index.ts
index b9b45b5fd2b9..98d43139798e 100644
--- a/packages/babel-plugin-proposal-function-sent/src/index.ts
+++ b/packages/babel-plugin-proposal-function-sent/src/index.ts
@@ -7,11 +7,14 @@ import type { Visitor } from "@babel/traverse";
 export default declare(api => {
   api.assertVersion(7);
 
-  const isFunctionSent = node =>
+  const isFunctionSent = (node: t.MetaProperty) =>
     t.isIdentifier(node.meta, { name: "function" }) &&
     t.isIdentifier(node.property, { name: "sent" });
 
-  const hasBeenReplaced = (node, sentId) =>
+  const hasBeenReplaced = (
+    node: t.Node,
+    sentId: string,
+  ): node is t.AssignmentExpression =>
     t.isAssignmentExpression(node) &&
     t.isIdentifier(node.left, { name: sentId });
 
diff --git a/packages/babel-plugin-proposal-json-strings/src/index.ts b/packages/babel-plugin-proposal-json-strings/src/index.ts
index 10e1c7bc9df0..039ac2fa4dae 100644
--- a/packages/babel-plugin-proposal-json-strings/src/index.ts
+++ b/packages/babel-plugin-proposal-json-strings/src/index.ts
@@ -6,7 +6,7 @@ import type { NodePath } from "@babel/traverse";
 export default declare(api => {
   api.assertVersion(7);
   const regex = /(\\*)([\u2028\u2029])/g;
-  function replace(match, escapes, separator) {
+  function replace(match: string, escapes: string, separator: string) {
     // If there's an odd number, that means the separator itself was escaped.
     // "\X" escapes X.
     // "\\X" escapes the backslash, so X is unescaped.
diff --git a/packages/babel-plugin-proposal-object-rest-spread/src/index.ts b/packages/babel-plugin-proposal-object-rest-spread/src/index.ts
index d0acd5b93711..33ad67f77abc 100644
--- a/packages/babel-plugin-proposal-object-rest-spread/src/index.ts
+++ b/packages/babel-plugin-proposal-object-rest-spread/src/index.ts
@@ -20,6 +20,7 @@ if (!process.env.BABEL_8_BREAKING) {
   var ZERO_REFS = t.isReferenced(node, property, pattern) ? 1 : 0;
 }
 
+type Param = NodePath<t.Function["params"][number]>;
 export interface Options {
   useBuiltIns?: boolean;
   loose?: boolean;
@@ -52,7 +53,7 @@ export default declare((api, opts: Options) => {
       : file.addHelper("extends");
   }
 
-  function hasRestElement(path) {
+  function hasRestElement(path: Param) {
     let foundRestElement = false;
     visitRestElements(path, restElement => {
       foundRestElement = true;
@@ -242,7 +243,7 @@ export default declare((api, opts: Options) => {
 
   function replaceRestElement(
     parentPath: NodePath<t.Function | t.CatchClause>,
-    paramPath: NodePath,
+    paramPath: Param | NodePath<t.AssignmentPattern["left"]>,
     container?: t.VariableDeclaration[],
   ): void {
     if (paramPath.isAssignmentPattern()) {
@@ -254,7 +255,12 @@ export default declare((api, opts: Options) => {
       const elements = paramPath.get("elements");
 
       for (let i = 0; i < elements.length; i++) {
-        replaceRestElement(parentPath, elements[i], container);
+        replaceRestElement(
+          parentPath,
+          // @ts-expect-error Fixme: handle TSAsExpression
+          elements[i],
+          container,
+        );
       }
     }
 
@@ -283,7 +289,7 @@ export default declare((api, opts: Options) => {
       // function a({ b, ...c }) {}
       Function(path) {
         const params = path.get("params");
-        const paramsWithRestElement = new Set();
+        const paramsWithRestElement = new Set<number>();
         const idsInRestParams = new Set();
         for (let i = 0; i < params.length; ++i) {
           const param = params[i];
@@ -300,7 +306,10 @@ export default declare((api, opts: Options) => {
         // example: f({...R}, a = R)
         let idInRest = false;
 
-        const IdentifierHandler = function (path, functionScope) {
+        const IdentifierHandler = function (
+          path: NodePath<t.Identifier>,
+          functionScope: Scope,
+        ) {
           const name = path.node.name;
           if (
             path.scope.getBinding(name) === functionScope.getBinding(name) &&
@@ -311,12 +320,12 @@ export default declare((api, opts: Options) => {
           }
         };
 
-        let i;
+        let i: number;
         for (i = 0; i < params.length && !idInRest; ++i) {
           const param = params[i];
           if (!paramsWithRestElement.has(i)) {
             if (param.isReferencedIdentifier() || param.isBindingIdentifier()) {
-              IdentifierHandler(path, path.scope);
+              IdentifierHandler(param, path.scope);
             } else {
               param.traverse(
                 {
@@ -337,7 +346,7 @@ export default declare((api, opts: Options) => {
             }
           }
         } else {
-          const shouldTransformParam = idx =>
+          const shouldTransformParam = (idx: number) =>
             idx >= i - 1 || paramsWithRestElement.has(idx);
           convertFunctionParams(
             path,
@@ -531,7 +540,7 @@ export default declare((api, opts: Options) => {
       },
 
       // taken from transform-destructuring/src/index.js#visitor
-      ForXStatement(path) {
+      ForXStatement(path: NodePath<t.ForXStatement>) {
         const { node, scope } = path;
         const leftPath = path.get("left");
         const left = node.left;
@@ -549,7 +558,7 @@ export default declare((api, opts: Options) => {
           ]);
 
           path.ensureBlock();
-          const body = node.body as t.BlockStatement;
+          const body = path.node.body;
 
           if (body.body.length === 0 && path.isCompletionRecord()) {
             body.body.unshift(
@@ -584,7 +593,7 @@ export default declare((api, opts: Options) => {
 
       // [{a, ...b}] = c;
       ArrayPattern(path) {
-        const objectPatterns = [];
+        const objectPatterns: t.VariableDeclarator[] = [];
 
         visitRestElements(path, path => {
           if (!path.parentPath.isObjectPattern()) {
@@ -620,7 +629,7 @@ export default declare((api, opts: Options) => {
       ObjectExpression(path, file) {
         if (!hasSpread(path.node)) return;
 
-        let helper;
+        let helper: t.Identifier | t.MemberExpression;
         if (setSpreadProperties) {
           helper = getExtendsHelper(file);
         } else {
@@ -638,8 +647,8 @@ export default declare((api, opts: Options) => {
           }
         }
 
-        let exp = null;
-        let props = [];
+        let exp: t.CallExpression = null;
+        let props: t.ObjectMember[] = [];
 
         function make() {
           const hadProps = props.length > 0;
diff --git a/packages/babel-plugin-proposal-object-rest-spread/src/shouldStoreRHSInTemporaryVariable.ts b/packages/babel-plugin-proposal-object-rest-spread/src/shouldStoreRHSInTemporaryVariable.ts
index 27cbf3765df0..0e0a1231e2af 100644
--- a/packages/babel-plugin-proposal-object-rest-spread/src/shouldStoreRHSInTemporaryVariable.ts
+++ b/packages/babel-plugin-proposal-object-rest-spread/src/shouldStoreRHSInTemporaryVariable.ts
@@ -15,7 +15,9 @@ const {
  * See https://github.com/babel/babel/pull/13711#issuecomment-914388382 for discussion
  * on further optimizations.
  */
-export default function shouldStoreRHSInTemporaryVariable(node: t.LVal) {
+export default function shouldStoreRHSInTemporaryVariable(
+  node: t.LVal,
+): boolean {
   if (isArrayPattern(node)) {
     const nonNullElements = node.elements.filter(element => element !== null);
     if (nonNullElements.length > 1) return true;
diff --git a/packages/babel-plugin-proposal-optional-chaining/src/transform.ts b/packages/babel-plugin-proposal-optional-chaining/src/transform.ts
index ed916d5bfcf3..313d5206cb12 100644
--- a/packages/babel-plugin-proposal-optional-chaining/src/transform.ts
+++ b/packages/babel-plugin-proposal-optional-chaining/src/transform.ts
@@ -8,7 +8,9 @@ import { willPathCastToBoolean, findOutermostTransparentParent } from "./util";
 
 const { ast } = template.expression;
 
-function isSimpleMemberExpression(expression) {
+function isSimpleMemberExpression(
+  expression: t.Expression,
+): expression is t.Identifier | t.Super | t.MemberExpression {
   expression = skipTransparentExprWrapperNodes(expression);
   return (
     t.isIdentifier(expression) ||
@@ -24,18 +26,21 @@ function isSimpleMemberExpression(expression) {
  * @param {NodePath} path
  * @returns {boolean}
  */
-function needsMemoize(path) {
-  let optionalPath = path;
+function needsMemoize(
+  path: NodePath<t.OptionalCallExpression | t.OptionalMemberExpression>,
+) {
+  let optionalPath: NodePath = path;
   const { scope } = path;
   while (
     optionalPath.isOptionalMemberExpression() ||
     optionalPath.isOptionalCallExpression()
   ) {
     const { node } = optionalPath;
-    const childKey = optionalPath.isOptionalMemberExpression()
-      ? "object"
-      : "callee";
-    const childPath = skipTransparentExprWrappers(optionalPath.get(childKey));
+    const childPath = skipTransparentExprWrappers(
+      optionalPath.isOptionalMemberExpression()
+        ? optionalPath.get("object")
+        : optionalPath.get("callee"),
+    );
     if (node.optional) {
       return !scope.isStatic(childPath.node);
     }
@@ -102,12 +107,16 @@ export function transform(
     isDeleteOperation = true;
   }
   for (let i = optionals.length - 1; i >= 0; i--) {
-    const node = optionals[i];
+    const node = optionals[i] as unknown as
+      | t.MemberExpression
+      | t.CallExpression;
 
     const isCall = t.isCallExpression(node);
-    const replaceKey = isCall ? "callee" : "object";
 
-    const chainWithTypes = node[replaceKey];
+    const chainWithTypes = isCall
+      ? // V8 intrinsics must not be an optional call
+        (node.callee as t.Expression)
+      : node.object;
     const chain = skipTransparentExprWrapperNodes(chainWithTypes);
 
     let ref;
@@ -115,12 +124,12 @@ export function transform(
     if (isCall && t.isIdentifier(chain, { name: "eval" })) {
       check = ref = chain;
       // `eval?.()` is an indirect eval call transformed to `(0,eval)()`
-      node[replaceKey] = t.sequenceExpression([t.numericLiteral(0), ref]);
+      node.callee = t.sequenceExpression([t.numericLiteral(0), ref]);
     } else if (pureGetters && isCall && isSimpleMemberExpression(chain)) {
       // If we assume getters are pure (avoiding a Function#call) and we are at the call,
       // we can avoid a needless memoize. We only do this if the callee is a simple member
       // expression, to avoid multiple calls to nested call expressions.
-      check = ref = chainWithTypes;
+      check = ref = node.callee;
     } else {
       ref = scope.maybeGenerateMemoised(chain);
       if (ref) {
@@ -133,7 +142,7 @@ export function transform(
           chainWithTypes,
         );
 
-        node[replaceKey] = ref;
+        isCall ? (node.callee = ref) : (node.object = ref);
       } else {
         check = ref = chainWithTypes;
       }
diff --git a/packages/babel-plugin-proposal-partial-application/src/index.ts b/packages/babel-plugin-proposal-partial-application/src/index.ts
index 6f88b628258d..29ba99d14eca 100644
--- a/packages/babel-plugin-proposal-partial-application/src/index.ts
+++ b/packages/babel-plugin-proposal-partial-application/src/index.ts
@@ -1,6 +1,7 @@
 import { declare } from "@babel/helper-plugin-utils";
 import syntaxPartialApplication from "@babel/plugin-syntax-partial-application";
 import { types as t } from "@babel/core";
+import type { Scope } from "@babel/traverse";
 
 export default declare(api => {
   api.assertVersion(7);
@@ -11,56 +12,67 @@ export default declare(api => {
    * @param node a callExpression node
    * @returns boolean
    */
-  function hasArgumentPlaceholder(node) {
+  function hasArgumentPlaceholder(node: t.CallExpression) {
     return node.arguments.some(arg => t.isArgumentPlaceholder(arg));
   }
 
-  function unwrapArguments(node, scope) {
-    const init = [];
-    for (let i = 0; i < node.arguments.length; i++) {
-      if (
-        !t.isArgumentPlaceholder(node.arguments[i]) &&
-        !t.isImmutable(node.arguments[i])
-      ) {
-        const id = scope.generateUidIdentifierBasedOnNode(
-          node.arguments[i],
-          "param",
-        );
+  function unwrapArguments(
+    { arguments: args }: t.CallExpression,
+    scope: Scope,
+  ) {
+    const init: t.AssignmentExpression[] = [];
+    for (let i = 0; i < args.length; i++) {
+      const node = args[i];
+      if (!t.isArgumentPlaceholder(node) && !t.isImmutable(node)) {
+        const id = scope.generateUidIdentifierBasedOnNode(node, "param");
         scope.push({ id });
-        if (t.isSpreadElement(node.arguments[i])) {
+        if (t.isSpreadElement(node)) {
           init.push(
             t.assignmentExpression(
               "=",
               t.cloneNode(id),
-              t.arrayExpression([t.spreadElement(node.arguments[i].argument)]),
+              t.arrayExpression([t.spreadElement(node.argument)]),
             ),
           );
-          node.arguments[i].argument = t.cloneNode(id);
+          node.argument = t.cloneNode(id);
         } else {
           init.push(
-            t.assignmentExpression("=", t.cloneNode(id), node.arguments[i]),
+            t.assignmentExpression(
+              "=",
+              t.cloneNode(id),
+              // @ts-ignore Fixme: may need to handle JSXNamespacedName here
+              node,
+            ),
           );
-          node.arguments[i] = t.cloneNode(id);
+          args[i] = t.cloneNode(id);
         }
       }
     }
     return init;
   }
 
-  function replacePlaceholders(node, scope) {
-    const placeholders = [];
-    const args = [];
+  type CallArgsWithoutPlaceholder = Exclude<
+    t.CallExpression["arguments"][number],
+    t.ArgumentPlaceholder
+  >[];
+
+  function replacePlaceholders(
+    node: t.CallExpression,
+    scope: Scope,
+  ): [t.Identifier[], CallArgsWithoutPlaceholder] {
+    const placeholders: t.Identifier[] = [];
+    const newArgs: CallArgsWithoutPlaceholder = [];
 
     node.arguments.forEach(arg => {
       if (t.isArgumentPlaceholder(arg)) {
         const id = scope.generateUid("_argPlaceholder");
         placeholders.push(t.identifier(id));
-        args.push(t.identifier(id));
+        newArgs.push(t.identifier(id));
       } else {
-        args.push(arg);
+        newArgs.push(arg);
       }
     });
-    return [placeholders, args];
+    return [placeholders, newArgs];
   }
 
   return {
diff --git a/packages/babel-plugin-proposal-pipeline-operator/src/buildOptimizedSequenceExpression.ts b/packages/babel-plugin-proposal-pipeline-operator/src/buildOptimizedSequenceExpression.ts
index 44909eac757a..e15e7eb3801b 100644
--- a/packages/babel-plugin-proposal-pipeline-operator/src/buildOptimizedSequenceExpression.ts
+++ b/packages/babel-plugin-proposal-pipeline-operator/src/buildOptimizedSequenceExpression.ts
@@ -1,58 +1,73 @@
 import { types as t } from "@babel/core";
+import type { NodePath } from "@babel/traverse";
 
 // tries to optimize sequence expressions in the format
 //   (a = b, (c => c + e)(a))
 // to
 //   (a = b, a + e)
-const buildOptimizedSequenceExpression = ({ call, path, placeholder }) => {
+
+type Options = {
+  call: t.CallExpression | t.AwaitExpression;
+  path: NodePath<t.BinaryExpression & { operator: "|>" }>;
+  placeholder: t.Identifier;
+};
+
+function isConciseArrowExpression(
+  node: t.Node,
+): node is t.ArrowFunctionExpression & { body: t.Expression } {
+  return (
+    t.isArrowFunctionExpression(node) &&
+    t.isExpression(node.body) &&
+    !node.async
+  );
+}
+
+const buildOptimizedSequenceExpression = ({
+  call,
+  path,
+  placeholder,
+}: Options) => {
+  // @ts-expect-error AwaitExpression does not have callee property
   const { callee: calledExpression } = call;
-  const pipelineLeft = path.node.left;
+  // pipelineLeft must not be a PrivateName
+  const pipelineLeft = path.node.left as t.Expression;
   const assign = t.assignmentExpression(
     "=",
     t.cloneNode(placeholder),
     pipelineLeft,
   );
 
-  let optimizeArrow =
-    t.isArrowFunctionExpression(calledExpression) &&
-    t.isExpression(calledExpression.body) &&
-    !calledExpression.async &&
-    !calledExpression.generator;
-  let param;
+  const expressionIsArrow = isConciseArrowExpression(calledExpression);
 
-  if (optimizeArrow) {
+  if (expressionIsArrow) {
+    let param;
+    let optimizeArrow = true;
     const { params } = calledExpression;
     if (params.length === 1 && t.isIdentifier(params[0])) {
       param = params[0];
     } else if (params.length > 0) {
       optimizeArrow = false;
     }
+    if (optimizeArrow && !param) {
+      // fixme: arrow function with 1 pattern argument will also go into this branch
+      // Arrow function with 0 arguments
+      return t.sequenceExpression([pipelineLeft, calledExpression.body]);
+    } else if (param) {
+      path.scope.push({ id: t.cloneNode(placeholder) });
+      path.get("right").scope.rename(param.name, placeholder.name);
+
+      return t.sequenceExpression([assign, calledExpression.body]);
+    }
   } else if (t.isIdentifier(calledExpression, { name: "eval" })) {
     const evalSequence = t.sequenceExpression([
       t.numericLiteral(0),
       calledExpression,
     ]);
 
-    call.callee = evalSequence;
-
-    path.scope.push({ id: t.cloneNode(placeholder) });
-
-    return t.sequenceExpression([assign, call]);
-  }
-
-  if (optimizeArrow && !param) {
-    // Arrow function with 0 arguments
-    return t.sequenceExpression([pipelineLeft, calledExpression.body]);
+    (call as t.CallExpression).callee = evalSequence;
   }
-
   path.scope.push({ id: t.cloneNode(placeholder) });
 
-  if (param) {
-    path.get("right").scope.rename(param.name, placeholder.name);
-
-    return t.sequenceExpression([assign, calledExpression.body]);
-  }
-
   return t.sequenceExpression([assign, call]);
 };
 
diff --git a/packages/babel-plugin-proposal-pipeline-operator/src/fsharpVisitor.ts b/packages/babel-plugin-proposal-pipeline-operator/src/fsharpVisitor.ts
index d285588f37df..5b1b5cac24cd 100644
--- a/packages/babel-plugin-proposal-pipeline-operator/src/fsharpVisitor.ts
+++ b/packages/babel-plugin-proposal-pipeline-operator/src/fsharpVisitor.ts
@@ -1,7 +1,8 @@
-import { types as t } from "@babel/core";
+import { types as t, type PluginObject } from "@babel/core";
+import type { NodePath } from "@babel/traverse";
 import buildOptimizedSequenceExpression from "./buildOptimizedSequenceExpression";
 
-const fsharpVisitor = {
+const fsharpVisitor: PluginObject["visitor"] = {
   BinaryExpression(path) {
     const { scope, node } = path;
     const { operator, left, right } = node;
@@ -16,7 +17,7 @@ const fsharpVisitor = {
     const sequence = buildOptimizedSequenceExpression({
       placeholder,
       call,
-      path,
+      path: path as NodePath<t.BinaryExpression & { operator: "|>" }>,
     });
     path.replaceWith(sequence);
   },
diff --git a/packages/babel-plugin-proposal-pipeline-operator/src/hackVisitor.ts b/packages/babel-plugin-proposal-pipeline-operator/src/hackVisitor.ts
index 36af34d537d5..c7e9d8d865c4 100644
--- a/packages/babel-plugin-proposal-pipeline-operator/src/hackVisitor.ts
+++ b/packages/babel-plugin-proposal-pipeline-operator/src/hackVisitor.ts
@@ -33,7 +33,7 @@ const topicReferenceVisitor: Visitor<State> = {
 // with sequence expressions containing assignment expressions
 // with automatically generated variables,
 // from inside to outside, from left to right.
-export default {
+const visitor: Visitor<PluginPass> = {
   BinaryExpression: {
     exit(path) {
       const { scope, node } = path;
@@ -52,7 +52,7 @@ export default {
         return;
       }
 
-      const visitorState = {
+      const visitorState: State = {
         topicReferences: [],
         // pipeBodyPath might be a function, and it won't be visited by
         // topicReferenceVisitor because traverse() skips the top-level
@@ -93,4 +93,6 @@ export default {
       );
     },
   },
-} as Visitor<PluginPass>;
+};
+
+export default visitor;
diff --git a/packages/babel-plugin-proposal-pipeline-operator/src/minimalVisitor.ts b/packages/babel-plugin-proposal-pipeline-operator/src/minimalVisitor.ts
index 66d3bff98af0..a7a0e3e72464 100644
--- a/packages/babel-plugin-proposal-pipeline-operator/src/minimalVisitor.ts
+++ b/packages/babel-plugin-proposal-pipeline-operator/src/minimalVisitor.ts
@@ -1,7 +1,8 @@
-import { types as t } from "@babel/core";
+import { types as t, type PluginPass } from "@babel/core";
+import type { NodePath, Visitor } from "@babel/traverse";
 import buildOptimizedSequenceExpression from "./buildOptimizedSequenceExpression";
 
-const minimalVisitor = {
+const minimalVisitor: Visitor<PluginPass> = {
   BinaryExpression(path) {
     const { scope, node } = path;
     const { operator, left, right } = node;
@@ -14,7 +15,7 @@ const minimalVisitor = {
       buildOptimizedSequenceExpression({
         placeholder,
         call,
-        path,
+        path: path as NodePath<t.BinaryExpression & { operator: "|>" }>,
       }),
     );
   },
diff --git a/packages/babel-plugin-proposal-private-property-in-object/src/index.ts b/packages/babel-plugin-proposal-private-property-in-object/src/index.ts
index fb6384e05232..c359eedcd193 100644
--- a/packages/babel-plugin-proposal-private-property-in-object/src/index.ts
+++ b/packages/babel-plugin-proposal-private-property-in-object/src/index.ts
@@ -7,7 +7,7 @@ import {
 } from "@babel/helper-create-class-features-plugin";
 import annotateAsPure from "@babel/helper-annotate-as-pure";
 import type * as t from "@babel/types";
-import type { NodePath } from "@babel/traverse";
+import type { NodePath, Scope } from "@babel/traverse";
 
 export interface Options {
   loose?: boolean;
@@ -23,29 +23,40 @@ export default declare((api, opt: Options) => {
   // The visitor of this plugin is only effective when not compiling
   // private fields and methods.
 
-  const classWeakSets = new WeakMap();
-  const fieldsWeakSets = new WeakMap();
+  const classWeakSets: WeakMap<t.Class, t.Identifier> = new WeakMap();
+  const fieldsWeakSets: WeakMap<
+    t.ClassPrivateProperty | t.ClassPrivateMethod,
+    t.Identifier
+  > = new WeakMap();
 
-  function unshadow(name, targetScope, scope) {
+  function unshadow(name: string, targetScope: Scope, scope: Scope) {
     while (scope !== targetScope) {
       if (scope.hasOwnBinding(name)) scope.rename(name);
       scope = scope.parent;
     }
   }
 
-  function injectToFieldInit(fieldPath, expr, before = false) {
+  function injectToFieldInit(
+    fieldPath: NodePath<t.ClassPrivateProperty | t.ClassProperty>,
+    expr: t.Expression,
+    before = false,
+  ) {
     if (fieldPath.node.value) {
+      const value = fieldPath.get("value");
       if (before) {
-        fieldPath.get("value").insertBefore(expr);
+        value.insertBefore(expr);
       } else {
-        fieldPath.get("value").insertAfter(expr);
+        value.insertAfter(expr);
       }
     } else {
       fieldPath.set("value", t.unaryExpression("void", expr));
     }
   }
 
-  function injectInitialization(classPath, init) {
+  function injectInitialization(
+    classPath: NodePath<t.Class>,
+    init: t.Expression,
+  ) {
     let firstFieldPath;
     let consturctorPath;
 
@@ -71,12 +82,22 @@ export default declare((api, opt: Options) => {
     }
   }
 
-  function getWeakSetId(weakSets, outerClass, reference, name = "", inject) {
-    let id = classWeakSets.get(reference.node);
+  function getWeakSetId<Ref extends t.Node>(
+    weakSets: WeakMap<Ref, t.Identifier>,
+    outerClass: NodePath<t.Class>,
+    reference: NodePath<Ref>,
+    name = "",
+    inject: (
+      reference: NodePath<Ref>,
+      expression: t.Expression,
+      before?: boolean,
+    ) => void,
+  ) {
+    let id = weakSets.get(reference.node);
 
     if (!id) {
       id = outerClass.scope.generateUidIdentifier(`${name || ""} brandCheck`);
-      classWeakSets.set(reference.node, id);
+      weakSets.set(reference.node, id);
 
       inject(reference, template.expression.ast`${t.cloneNode(id)}.add(this)`);
 
@@ -105,13 +126,17 @@ export default declare((api, opt: Options) => {
 
         const { name } = node.left.id;
 
-        let privateElement;
+        let privateElement: NodePath<
+          t.ClassPrivateMethod | t.ClassPrivateProperty
+        >;
         const outerClass = path.findParent(path => {
           if (!path.isClass()) return false;
 
-          privateElement = path
-            .get("body.body")
-            .find(({ node }) => t.isPrivate(node) && node.key.id.name === name);
+          privateElement = path.get("body.body").find(
+            ({ node }) =>
+              // fixme: Support class accessor property
+              t.isPrivate(node) && node.key.id.name === name,
+          ) as NodePath<t.ClassPrivateMethod | t.ClassPrivateProperty>;
 
           return !!privateElement;
         }) as NodePath<t.Class>;
@@ -124,7 +149,7 @@ export default declare((api, opt: Options) => {
           return;
         }
 
-        if (privateElement.isMethod()) {
+        if (privateElement.node.type === "ClassPrivateMethod") {
           if (privateElement.node.static) {
             if (outerClass.node.id) {
               unshadow(outerClass.node.id.name, outerClass.scope, path.scope);
@@ -153,10 +178,10 @@ export default declare((api, opt: Options) => {
           // Private fields might not all be initialized: see the 'halfConstructed'
           // example at https://v8.dev/features/private-brand-checks.
 
-          const id = getWeakSetId(
+          const id = getWeakSetId<t.ClassPrivateProperty>(
             fieldsWeakSets,
             outerClass,
-            privateElement,
+            privateElement as NodePath<t.ClassPrivateProperty>,
             privateElement.node.key.id.name,
             injectToFieldInit,
           );
diff --git a/packages/babel-plugin-proposal-record-and-tuple/src/index.ts b/packages/babel-plugin-proposal-record-and-tuple/src/index.ts
index 2c148a3451f8..b41c5197f63d 100644
--- a/packages/babel-plugin-proposal-record-and-tuple/src/index.ts
+++ b/packages/babel-plugin-proposal-record-and-tuple/src/index.ts
@@ -34,6 +34,10 @@ type State = {
   programPath: NodePath<t.Program>;
 };
 
+// program -> cacheKey -> localBindingName
+type Cache = Map<string, string>;
+type ImportCache = WeakMap<t.Program, Cache>;
+
 export default declare<State>((api, options: Options) => {
   api.assertVersion(7);
 
@@ -48,16 +52,28 @@ export default declare<State>((api, options: Options) => {
     !!options.polyfillModuleName,
   );
 
-  // program -> cacheKey -> localBindingName
-  const importCaches = new WeakMap();
+  const importCaches: ImportCache = new WeakMap();
 
-  function getOr(map, key, getDefault) {
+  function getOr<K, V>(map: Map<K, V>, key: K, getDefault: () => V): V;
+  function getOr<K extends object, V>(
+    map: WeakMap<K, V>,
+    key: K,
+    getDefault: () => V,
+  ): V;
+  function getOr<K extends object, V>(
+    map: WeakMap<K, V>,
+    key: K,
+    getDefault: () => V,
+  ) {
     let value = map.get(key);
     if (!value) map.set(key, (value = getDefault()));
     return value;
   }
 
-  function getBuiltIn(name, programPath) {
+  function getBuiltIn(
+    name: "Record" | "Tuple",
+    programPath: NodePath<t.Program>,
+  ) {
     if (!shouldImportPolyfill) return t.identifier(name);
     if (!programPath) {
       throw new Error("Internal error: unable to find the Program node.");
@@ -65,7 +81,11 @@ export default declare<State>((api, options: Options) => {
 
     const cacheKey = `${name}:${isModule(programPath)}`;
 
-    const cache = getOr(importCaches, programPath.node, () => new Map());
+    const cache = getOr(
+      importCaches,
+      programPath.node,
+      () => new Map<string, string>(),
+    );
     const localBindingName = getOr(cache, cacheKey, () => {
       return addNamed(programPath, name, polyfillModuleName, {
         importedInterop: "uncompiled",
diff --git a/packages/babel-plugin-syntax-typescript/src/index.ts b/packages/babel-plugin-syntax-typescript/src/index.ts
index 933b8e8c5d8a..01fb877d5a88 100644
--- a/packages/babel-plugin-syntax-typescript/src/index.ts
+++ b/packages/babel-plugin-syntax-typescript/src/index.ts
@@ -1,7 +1,8 @@
 import { declare } from "@babel/helper-plugin-utils";
+import type { ParserPlugin } from "@babel/parser";
 
-function removePlugin(plugins, name) {
-  const indices = [];
+function removePlugin(plugins: ParserPlugin[], name: string) {
+  const indices: number[] = [];
   plugins.forEach((plugin, i) => {
     const n = Array.isArray(plugin) ? plugin[0] : plugin;
 
diff --git a/packages/babel-plugin-transform-block-scoped-functions/src/index.ts b/packages/babel-plugin-transform-block-scoped-functions/src/index.ts
index 1e392452232b..811645d8bfd0 100644
--- a/packages/babel-plugin-transform-block-scoped-functions/src/index.ts
+++ b/packages/babel-plugin-transform-block-scoped-functions/src/index.ts
@@ -1,16 +1,14 @@
 import { declare } from "@babel/helper-plugin-utils";
 import { types as t } from "@babel/core";
+import type { NodePath } from "@babel/traverse";
 
 export default declare(api => {
   api.assertVersion(7);
 
-  function statementList(key, path) {
-    const paths = path.get(key);
-
+  function transformStatementList(paths: NodePath<t.Statement>[]) {
     for (const path of paths) {
-      const func = path.node;
       if (!path.isFunctionDeclaration()) continue;
-
+      const func = path.node;
       const declar = t.variableDeclaration("let", [
         t.variableDeclarator(func.id, t.toExpression(func)),
       ]);
@@ -39,11 +37,11 @@ export default declare(api => {
           return;
         }
 
-        statementList("body", path);
+        transformStatementList(path.get("body"));
       },
 
       SwitchCase(path) {
-        statementList("consequent", path);
+        transformStatementList(path.get("consequent"));
       },
     },
   };
diff --git a/packages/babel-plugin-transform-block-scoping/src/index.ts b/packages/babel-plugin-transform-block-scoping/src/index.ts
index edf7daf82eb9..bb927c6aca91 100644
--- a/packages/babel-plugin-transform-block-scoping/src/index.ts
+++ b/packages/babel-plugin-transform-block-scoping/src/index.ts
@@ -3,7 +3,7 @@ import type { NodePath, Visitor, Scope } from "@babel/traverse";
 import { visitor as tdzVisitor } from "./tdz";
 import type { TDZVisitorState } from "./tdz";
 import { traverse, template, types as t } from "@babel/core";
-import type { File } from "@babel/core";
+import type { PluginPass } from "@babel/core";
 
 const DONE = new WeakSet();
 
@@ -62,7 +62,7 @@ export default declare((api, opts: Options) => {
         }
       },
 
-      Loop(path, state) {
+      Loop(path: NodePath<t.Loop>, state) {
         const { parent, scope } = path;
         path.ensureBlock();
         const blockScoping = new BlockScoping(
@@ -109,21 +109,27 @@ export default declare((api, opts: Options) => {
           blockScoping.run();
         }
       },
-    } as Visitor<File>,
+    },
   };
 });
 
-function ignoreBlock(path) {
+function ignoreBlock(path: NodePath) {
   return t.isLoop(path.parent) || t.isCatchClause(path.parent);
 }
 
-const buildRetCheck = template(`
+const buildRetCheck = template.statement(`
   if (typeof RETURN === "object") return RETURN.v;
 `);
 
-function isBlockScoped(node) {
+function isBlockScoped(node: t.Node): node is t.VariableDeclaration {
   if (!t.isVariableDeclaration(node)) return false;
-  if (node[t.BLOCK_SCOPED_SYMBOL]) return true;
+  if (
+    // @ts-expect-error Fixme: document symbol properties
+    node[t.BLOCK_SCOPED_SYMBOL]
+  ) {
+    return true;
+  }
+
   if (node.kind !== "let" && node.kind !== "const") return false;
   return true;
 }
@@ -132,7 +138,7 @@ function isBlockScoped(node) {
  * If there is a loop ancestor closer than the closest function, we
  * consider ourselves to be in a loop.
  */
-function isInLoop(path) {
+function isInLoop(path: NodePath) {
   const loopOrFunctionParent = path.find(
     path => path.isLoop() || path.isFunction(),
   );
@@ -141,10 +147,10 @@ function isInLoop(path) {
 }
 
 function convertBlockScopedToVar(
-  path,
-  node,
-  parent,
-  scope,
+  path: NodePath<t.VariableDeclaration>,
+  node: t.VariableDeclaration,
+  parent: t.Node,
+  scope: Scope,
   moveBindingsToParent = false,
 ) {
   if (!node) {
@@ -159,6 +165,7 @@ function convertBlockScopedToVar(
     }
   }
 
+  // @ts-expect-error todo(flow->ts): avoid mutations
   node[t.BLOCK_SCOPED_SYMBOL] = true;
   node.kind = "var";
 
@@ -173,15 +180,12 @@ function convertBlockScopedToVar(
   }
 }
 
-function isVar(node): node is t.VariableDeclaration {
+function isVar(node: t.Node): node is t.VariableDeclaration {
   return t.isVariableDeclaration(node, { kind: "var" }) && !isBlockScoped(node);
 }
 
 interface LetReferenceVisitorState extends TDZVisitorState {
-  tdzEnabled: boolean;
   loopDepth: number;
-  addHelper: (name) => any;
-  letReferences: any;
   closurify: boolean;
 }
 
@@ -260,12 +264,12 @@ const hoistVarDeclarationsVisitor: Visitor<BlockScoping> = {
 type LoopVisitorState = {
   inSwitchCase: boolean;
   hasBreakContinue: boolean;
-  innerLabels: any[];
+  innerLabels: string[];
   hasReturn: boolean;
   ignoreLabeless: boolean;
   loopIgnored: WeakSet<t.Node>;
   isLoop: boolean;
-  map: any;
+  map: Map<string, t.BreakStatement | t.ContinueStatement>;
 };
 
 const loopLabelVisitor: Visitor<LoopVisitorState> = {
@@ -298,7 +302,7 @@ const continuationVisitor: Visitor<ContinuationVisitorState> = {
   },
 };
 
-function loopNodeTo(node) {
+function loopNodeTo(node: t.Node) {
   if (t.isBreakStatement(node)) {
     return "break";
   } else if (t.isContinueStatement(node)) {
@@ -360,7 +364,7 @@ const loopVisitor: Visitor<LoopVisitorState> = {
       }
 
       state.hasBreakContinue = true;
-      state.map[loopText] = node;
+      state.map.set(loopText, node);
       replace = t.stringLiteral(loopText);
     }
 
@@ -383,7 +387,7 @@ const loopVisitor: Visitor<LoopVisitorState> = {
   },
 };
 
-function isStrict(path) {
+function isStrict(path: NodePath) {
   return !!path.find(({ node }) => {
     if (t.isProgram(node)) {
       if (node.sourceType === "module") return true;
@@ -396,31 +400,31 @@ function isStrict(path) {
 }
 
 class BlockScoping {
-  private parent: any;
-  private state: any;
+  private parent: t.Node;
+  private state: PluginPass;
   private scope: Scope;
   private throwIfClosureRequired: boolean;
   private tdzEnabled: boolean;
-  private blockPath: NodePath;
-  private block: t.Node;
+  private blockPath: NodePath<t.Block | t.SwitchStatement>;
+  private block: t.Block | t.SwitchStatement;
   private outsideLetReferences: Map<string, t.Identifier>;
   private hasLetReferences: boolean;
-  private letReferences: any;
-  private body: any[];
+  private letReferences: Map<string, t.Identifier>;
+  private body: t.Statement[];
   // todo(flow->ts) add more specific type
   private loopParent: t.Node;
   private loopLabel: t.Identifier;
   private loopPath: NodePath<t.Loop>;
   private loop: t.Loop;
-  private has: any;
+  private has: LoopVisitorState;
   constructor(
     loopPath: NodePath<t.Loop> | undefined | null,
-    blockPath: NodePath,
-    parent: any,
+    blockPath: NodePath<t.Block | t.SwitchStatement>,
+    parent: t.Node,
     scope: Scope,
     throwIfClosureRequired: boolean,
     tdzEnabled: boolean,
-    state: any,
+    state: PluginPass,
   ) {
     this.parent = parent;
     this.scope = scope;
@@ -530,6 +534,7 @@ class BlockScoping {
             ]),
           );
         } else if (violation.isForXStatement()) {
+          // @ts-expect-error TS requires explicit annotation of "violation"
           violation.ensureBlock();
           violation
             .get("left")
@@ -669,15 +674,14 @@ class BlockScoping {
     const args = Array.from(outsideRefs.values(), node => t.cloneNode(node));
     const params = args.map(id => t.cloneNode(id));
 
-    const isSwitch = this.blockPath.isSwitchStatement();
+    const isSwitch = block.type === "SwitchStatement";
 
     // build the closure that we're going to wrap the block with, possible wrapping switch(){}
     const fn = t.functionExpression(
       null,
       params,
-      // @ts-expect-error todo(flow->ts) improve block type annotations
       t.blockStatement(isSwitch ? [block] : block.body),
-    );
+    ) as t.FunctionExpression & { params: t.Identifier[] };
 
     // continuation
     this.addContinuations(fn);
@@ -730,20 +734,19 @@ class BlockScoping {
       index = this.body.length - 1;
     }
 
-    let callPath;
+    let callPath: NodePath;
     // replace the current block body with the one we're going to build
     if (isSwitch) {
       const { parentPath, listKey, key } = this.blockPath;
 
       this.blockPath.replaceWithMultiple(this.body);
-      callPath = parentPath.get(listKey)[key + index];
+      callPath = parentPath.get(listKey)[(key as number) + index];
     } else {
-      // @ts-expect-error todo(flow->ts) improve block type annotations
       block.body = this.body;
       callPath = this.blockPath.get("body")[index];
     }
 
-    const placeholder = callPath.get(placeholderPath);
+    const placeholder = callPath.get(placeholderPath) as NodePath;
 
     let fnPath;
     if (this.loop) {
@@ -773,7 +776,7 @@ class BlockScoping {
    * Reference: https://github.com/babel/babel/issues/1078
    */
 
-  addContinuations(fn) {
+  addContinuations(fn: t.FunctionExpression & { params: t.Identifier[] }) {
     const state: ContinuationVisitorState = {
       reassignments: {},
       returnStatements: [],
@@ -834,17 +837,24 @@ class BlockScoping {
       }
     }
 
-    const addDeclarationsFromChild = (path, node) => {
-      node = node || path.node;
+    const addDeclarationsFromChild = (
+      path: NodePath<t.Statement | t.SwitchCase>,
+      node: t.Statement | t.SwitchCase,
+    ) => {
       if (
         t.isClassDeclaration(node) ||
         t.isFunctionDeclaration(node) ||
         isBlockScoped(node)
       ) {
         if (isBlockScoped(node)) {
-          convertBlockScopedToVar(path, node, block, this.scope);
+          convertBlockScopedToVar(
+            path as NodePath<t.VariableDeclaration>,
+            node,
+            block,
+            this.scope,
+          );
         }
-        if (node.declarations) {
+        if (node.type === "VariableDeclaration") {
           for (let i = 0; i < node.declarations.length; i++) {
             declarators.push(node.declarations[i]);
           }
@@ -857,22 +867,11 @@ class BlockScoping {
       }
     };
 
-    // @ts-expect-error todo(flow->ts) check block node type instead
-    if (block.body) {
-      const declarPaths = this.blockPath.get("body");
-      // @ts-expect-error todo(flow->ts)
-      for (let i = 0; i < block.body.length; i++) {
-        // @ts-expect-error todo(flow->ts)
-        addDeclarationsFromChild(declarPaths[i]);
-      }
-    }
-
-    // @ts-expect-error todo(flow->ts) check block node type instead
-    if (block.cases) {
-      const declarPaths = this.blockPath.get("cases");
-      // @ts-expect-error todo(flow->ts)
+    if (block.type === "SwitchStatement") {
+      const declarPaths = (this.blockPath as NodePath<t.SwitchStatement>).get(
+        "cases",
+      );
       for (let i = 0; i < block.cases.length; i++) {
-        // @ts-expect-error todo(flow->ts)
         const consequents = block.cases[i].consequent;
 
         for (let j = 0; j < consequents.length; j++) {
@@ -880,6 +879,11 @@ class BlockScoping {
           addDeclarationsFromChild(declarPaths[i], declar);
         }
       }
+    } else {
+      const declarPaths = (this.blockPath as NodePath<t.Block>).get("body");
+      for (let i = 0; i < block.body.length; i++) {
+        addDeclarationsFromChild(declarPaths[i], declarPaths[i].node);
+      }
     }
 
     //
@@ -933,7 +937,7 @@ class BlockScoping {
       innerLabels: [],
       hasReturn: false,
       isLoop: !!this.loop,
-      map: {},
+      map: new Map(),
       loopIgnored: new WeakSet(),
     };
 
@@ -988,11 +992,11 @@ class BlockScoping {
     const has = this.has;
 
     if (has.hasBreakContinue) {
-      for (const key of Object.keys(has.map)) {
+      for (const key of has.map.keys()) {
         body.push(
           t.ifStatement(
             t.binaryExpression("===", t.identifier(ret), t.stringLiteral(key)),
-            has.map[key],
+            has.map.get(key),
           ),
         );
       }
diff --git a/packages/babel-plugin-transform-block-scoping/src/tdz.ts b/packages/babel-plugin-transform-block-scoping/src/tdz.ts
index c6ad42755634..5f3bdcbcb0d2 100644
--- a/packages/babel-plugin-transform-block-scoping/src/tdz.ts
+++ b/packages/babel-plugin-transform-block-scoping/src/tdz.ts
@@ -1,7 +1,10 @@
-import { types as t, template } from "@babel/core";
-import type { Visitor } from "@babel/traverse";
+import { types as t, template, type PluginPass } from "@babel/core";
+import type { NodePath, Scope, Visitor } from "@babel/traverse";
 
-function getTDZStatus(refPath, bindingPath) {
+function getTDZStatus(
+  refPath: NodePath<t.Identifier | t.JSXIdentifier>,
+  bindingPath: NodePath,
+) {
   const executionStatus = bindingPath._guessExecutionStatusRelativeTo(refPath);
 
   if (executionStatus === "before") {
@@ -13,14 +16,22 @@ function getTDZStatus(refPath, bindingPath) {
   }
 }
 
-function buildTDZAssert(node, state) {
+function buildTDZAssert(
+  node: t.Identifier | t.JSXIdentifier,
+  state: TDZVisitorState,
+) {
   return t.callExpression(state.addHelper("temporalRef"), [
+    // @ts-expect-error Fixme: we may need to handle JSXIdentifier
     node,
     t.stringLiteral(node.name),
   ]);
 }
 
-function isReference(node, scope, state) {
+function isReference(
+  node: t.Identifier | t.JSXIdentifier,
+  scope: Scope,
+  state: TDZVisitorState,
+) {
   const declared = state.letReferences.get(node.name);
   if (!declared) return false;
 
@@ -32,7 +43,8 @@ const visitedMaybeTDZNodes = new WeakSet();
 
 export interface TDZVisitorState {
   tdzEnabled: boolean;
-  addHelper: (name) => any;
+  addHelper: PluginPass["addHelper"];
+  letReferences: Map<string, t.Identifier>;
 }
 
 export const visitor: Visitor<TDZVisitorState> = {
diff --git a/packages/babel-plugin-transform-classes/src/index.ts b/packages/babel-plugin-transform-classes/src/index.ts
index 598b6a7656bb..052d6ab514ba 100644
--- a/packages/babel-plugin-transform-classes/src/index.ts
+++ b/packages/babel-plugin-transform-classes/src/index.ts
@@ -7,7 +7,7 @@ import globals from "globals";
 import transformClass from "./transformClass";
 import type { Visitor, NodePath } from "@babel/traverse";
 
-const getBuiltinClasses = (category: string) =>
+const getBuiltinClasses = (category: keyof typeof globals) =>
   Object.keys(globals[category]).filter(name => /^[A-Z]/.test(name));
 
 const builtinClasses = new Set([
diff --git a/packages/babel-plugin-transform-classes/src/inline-createSuper-helpers.ts b/packages/babel-plugin-transform-classes/src/inline-createSuper-helpers.ts
index d0a8b592a359..c52758a3d87d 100644
--- a/packages/babel-plugin-transform-classes/src/inline-createSuper-helpers.ts
+++ b/packages/babel-plugin-transform-classes/src/inline-createSuper-helpers.ts
@@ -1,8 +1,8 @@
-import { template, types as t } from "@babel/core";
+import { template, types as t, type File } from "@babel/core";
 
 const helperIDs = new WeakMap();
 
-export default function addCreateSuperHelper(file) {
+export default function addCreateSuperHelper(file: File) {
   if (helperIDs.has(file)) {
     // TODO: Only use t.cloneNode in Babel 8
     // t.cloneNode isn't supported in every version
diff --git a/packages/babel-plugin-transform-classes/src/transformClass.ts b/packages/babel-plugin-transform-classes/src/transformClass.ts
index 05712a39c8c8..80046997485e 100644
--- a/packages/babel-plugin-transform-classes/src/transformClass.ts
+++ b/packages/babel-plugin-transform-classes/src/transformClass.ts
@@ -1,9 +1,9 @@
-import type { NodePath, Visitor } from "@babel/traverse";
+import type { NodePath, Scope, Visitor } from "@babel/traverse";
 import nameFunction from "@babel/helper-function-name";
 import ReplaceSupers from "@babel/helper-replace-supers";
 import environmentVisitor from "@babel/helper-environment-visitor";
 import optimiseCall from "@babel/helper-optimise-call-expression";
-import { traverse, template, types as t } from "@babel/core";
+import { traverse, template, types as t, type File } from "@babel/core";
 import annotateAsPure from "@babel/helper-annotate-as-pure";
 
 import addCreateSuperHelper from "./inline-createSuper-helpers";
@@ -15,7 +15,13 @@ type ClassAssumptions = {
   noClassCalls: boolean;
 };
 
-function buildConstructor(classRef, constructorBody, node) {
+type ClassConstructor = t.ClassMethod & { kind: "constructor" };
+
+function buildConstructor(
+  classRef: t.Identifier,
+  constructorBody: t.BlockStatement,
+  node: t.Class,
+) {
   const func = t.functionDeclaration(
     t.cloneNode(classRef),
     [],
@@ -25,14 +31,75 @@ function buildConstructor(classRef, constructorBody, node) {
   return func;
 }
 
+type Descriptor = {
+  key: t.Expression;
+  get?: t.Expression | null;
+  set?: t.Expression | null;
+  value?: t.Expression | null;
+  constructor?: t.Expression | null;
+};
+
+type State = {
+  parent: t.Node;
+  scope: Scope;
+  node: t.Class;
+  path: NodePath<t.Class>;
+  file: File;
+
+  classId: t.Identifier | void;
+  classRef: t.Identifier;
+  superFnId: t.Identifier;
+  superName: t.Expression | null;
+  superReturns: NodePath<t.ReturnStatement>[];
+  isDerived: boolean;
+  extendsNative: boolean;
+
+  construct: t.FunctionDeclaration;
+  constructorBody: t.BlockStatement;
+  userConstructor: ClassConstructor;
+  userConstructorPath: NodePath<ClassConstructor>;
+  hasConstructor: boolean;
+
+  body: t.Statement[];
+  superThises: NodePath<t.ThisExpression>[];
+  pushedConstructor: boolean;
+  pushedInherits: boolean;
+  pushedCreateClass: boolean;
+  protoAlias: t.Identifier | null;
+  isLoose: boolean;
+
+  dynamicKeys: Map<string, t.Expression>;
+
+  methods: {
+    // 'list' is in the same order as the elements appear in the class body.
+    // if there aren't computed keys, we can safely reorder class elements
+    // and use 'map' to merge duplicates.
+    instance: {
+      hasComputed: boolean;
+      list: Descriptor[];
+      map: Map<string, Descriptor>;
+    };
+    static: {
+      hasComputed: boolean;
+      list: Descriptor[];
+      map: Map<string, Descriptor>;
+    };
+  };
+};
+
+type PropertyInfo = {
+  instance: t.ObjectExpression[] | null;
+  static: t.ObjectExpression[] | null;
+};
+
 export default function transformClass(
-  path: NodePath,
-  file: any,
+  path: NodePath<t.Class>,
+  file: File,
   builtinClasses: ReadonlySet<string>,
   isLoose: boolean,
   assumptions: ClassAssumptions,
 ) {
-  const classState = {
+  const classState: State = {
     parent: undefined,
     scope: undefined,
     node: undefined,
@@ -42,7 +109,7 @@ export default function transformClass(
     classId: undefined,
     classRef: undefined,
     superFnId: undefined,
-    superName: undefined,
+    superName: null,
     superReturns: [],
     isDerived: false,
     extendsNative: false,
@@ -53,7 +120,6 @@ export default function transformClass(
     userConstructorPath: undefined,
     hasConstructor: false,
 
-    staticPropBody: [],
     body: [],
     superThises: [],
     pushedConstructor: false,
@@ -65,9 +131,6 @@ export default function transformClass(
     dynamicKeys: new Map(),
 
     methods: {
-      // 'list' is in the same order as the elements appear in the class body.
-      // if there aren't computed keys, we can safely reorder class elements
-      // and use 'map' to merge duplicates.
       instance: {
         hasComputed: false,
         list: [],
@@ -81,7 +144,7 @@ export default function transformClass(
     },
   };
 
-  const setState = newState => {
+  const setState = (newState: Partial<State>) => {
     Object.assign(classState, newState);
   };
 
@@ -94,7 +157,7 @@ export default function transformClass(
     },
   ]);
 
-  function createClassHelper(args) {
+  function createClassHelper(args: t.Expression[]) {
     return t.callExpression(classState.file.addHelper("createClass"), args);
   }
 
@@ -110,7 +173,7 @@ export default function transformClass(
     }
     if (hasConstructor) return;
 
-    let params, body;
+    let params: t.FunctionExpression["params"], body;
 
     if (classState.isDerived) {
       const constructor = template.expression.ast`
@@ -179,7 +242,7 @@ export default function transformClass(
 
         replaceSupers.replace();
 
-        const superReturns = [];
+        const superReturns: NodePath<t.ReturnStatement>[] = [];
         path.traverse(
           traverse.visitors.merge([
             environmentVisitor,
@@ -194,7 +257,7 @@ export default function transformClass(
         );
 
         if (isConstructor) {
-          pushConstructor(superReturns, node, path);
+          pushConstructor(superReturns, node as ClassConstructor, path);
         } else {
           pushMethod(node, path);
         }
@@ -207,19 +270,19 @@ export default function transformClass(
 
     const { body } = classState;
 
-    const props = {
+    const props: PropertyInfo = {
       instance: null,
       static: null,
     };
 
-    for (const placement of ["static", "instance"]) {
+    for (const placement of ["static", "instance"] as const) {
       if (classState.methods[placement].list.length) {
         props[placement] = classState.methods[placement].list.map(desc => {
           const obj = t.objectExpression([
             t.objectProperty(t.identifier("key"), desc.key),
           ]);
 
-          for (const kind of ["get", "set", "value"]) {
+          for (const kind of ["get", "set", "value"] as const) {
             if (desc[kind] != null) {
               obj.properties.push(
                 t.objectProperty(t.identifier(kind), desc[kind]),
@@ -250,7 +313,12 @@ export default function transformClass(
     }
   }
 
-  function wrapSuperCall(bareSuper, superRef, thisRef, body) {
+  function wrapSuperCall(
+    bareSuper: NodePath<t.CallExpression>,
+    superRef: t.Expression,
+    thisRef: () => t.Identifier,
+    body: NodePath<t.BlockStatement>,
+  ) {
     const bareSuperNode = bareSuper.node;
     let call;
 
@@ -373,7 +441,7 @@ export default function transformClass(
     let wrapReturn;
 
     if (classState.isLoose) {
-      wrapReturn = returnArg => {
+      wrapReturn = (returnArg: t.Expression | void) => {
         const thisExpr = t.callExpression(
           classState.file.addHelper("assertThisInitialized"),
           [thisRef()],
@@ -383,11 +451,16 @@ export default function transformClass(
           : thisExpr;
       };
     } else {
-      wrapReturn = returnArg =>
-        t.callExpression(
+      wrapReturn = (returnArg: t.Expression | undefined) => {
+        const returnParams: t.Expression[] = [thisRef()];
+        if (returnArg != null) {
+          returnParams.push(returnArg);
+        }
+        return t.callExpression(
           classState.file.addHelper("possibleConstructorReturn"),
-          [thisRef()].concat(returnArg || []),
+          returnParams,
         );
+      };
     }
 
     // if we have a return as the last node in the body then we've already caught that
@@ -428,11 +501,13 @@ export default function transformClass(
         ? t.stringLiteral(String(node.key.value))
         : t.toComputedKey(node);
 
-    let fn = t.toExpression(node);
+    let fn: t.Expression = t.toExpression(node);
 
     if (t.isStringLiteral(key)) {
       // infer function name
       if (node.kind === "method") {
+        // @ts-ignore Fixme: we are passing a ClassMethod to nameFunction, but nameFunction
+        // does not seem to support it
         fn = nameFunction({ id: key, node: node, scope });
       }
     } else {
@@ -440,7 +515,7 @@ export default function transformClass(
       methods.hasComputed = true;
     }
 
-    let descriptor;
+    let descriptor: Descriptor;
     if (
       !methods.hasComputed &&
       methods.map.has((key as t.StringLiteral).value)
@@ -455,7 +530,12 @@ export default function transformClass(
         descriptor.value = null;
       }
     } else {
-      descriptor = { key: key, [descKey]: fn };
+      descriptor = {
+        key:
+          // private name has been handled in class-properties transform
+          key as t.Expression,
+        [descKey]: fn,
+      } as Descriptor;
       methods.list.push(descriptor);
 
       if (!methods.hasComputed) {
@@ -464,7 +544,7 @@ export default function transformClass(
     }
   }
 
-  function processMethod(node, scope) {
+  function processMethod(node: t.ClassMethod, scope: Scope) {
     if (assumptions.setClassMethods && !node.decorators) {
       // use assignments instead of define properties for loose classes
       let { classRef } = classState;
@@ -478,8 +558,9 @@ export default function transformClass(
         node.computed || t.isLiteral(node.key),
       );
 
-      let func = t.functionExpression(
+      let func: t.Expression = t.functionExpression(
         null,
+        // @ts-expect-error Fixme: should throw when we see TSParameterProperty
         node.params,
         node.body,
         node.generator,
@@ -526,9 +607,9 @@ export default function transformClass(
    * Replace the constructor body of our class.
    */
   function pushConstructor(
-    superReturns,
-    method: t.ClassMethod,
-    path: NodePath,
+    superReturns: NodePath<t.ReturnStatement>[],
+    method: ClassConstructor,
+    path: NodePath<ClassConstructor>,
   ) {
     setState({
       userConstructorPath: path,
@@ -541,6 +622,7 @@ export default function transformClass(
 
     t.inheritsComments(construct, method);
 
+    // @ts-expect-error Fixme: should throw when we see TSParameterProperty
     construct.params = method.params;
 
     t.inherits(construct.body, method.body);
@@ -603,11 +685,7 @@ export default function transformClass(
   }
 
   function extractDynamicKeys() {
-    const { dynamicKeys, node, scope } = classState as {
-      dynamicKeys: Map<string, t.Expression>;
-      node: t.Class;
-      scope: NodePath["scope"];
-    };
+    const { dynamicKeys, node, scope } = classState;
 
     for (const elem of node.body.body) {
       if (!t.isClassMethod(elem) || !elem.computed) continue;
@@ -652,8 +730,8 @@ export default function transformClass(
   }
 
   function classTransformer(
-    path: NodePath,
-    file,
+    path: NodePath<t.Class>,
+    file: File,
     builtinClasses: ReadonlySet<string>,
     isLoose: boolean,
   ) {
@@ -679,7 +757,7 @@ export default function transformClass(
 
     setState({
       extendsNative:
-        classState.isDerived &&
+        t.isIdentifier(classState.superName) &&
         builtinClasses.has(classState.superName.name) &&
         !classState.scope.hasBinding(
           classState.superName.name,
@@ -712,12 +790,6 @@ export default function transformClass(
       );
     }
 
-    body.push(
-      ...classState.staticPropBody.map(fn =>
-        fn(t.cloneNode(classState.classRef)),
-      ),
-    );
-
     const isStrict = path.isInStrictMode();
     let constructorOnly = classState.classId && body.length === 1;
     if (constructorOnly && !isStrict) {
@@ -732,18 +804,23 @@ export default function transformClass(
       }
     }
 
-    const directives = constructorOnly ? body[0].body.directives : [];
+    const directives = constructorOnly
+      ? (body[0] as t.FunctionExpression | t.FunctionDeclaration).body
+          .directives
+      : [];
     if (!isStrict) {
       directives.push(t.directive(t.directiveLiteral("use strict")));
     }
 
     if (constructorOnly) {
       // named class with only a constructor
-      const expr = t.toExpression(body[0]);
+      const expr = t.toExpression(
+        body[0] as t.FunctionExpression | t.FunctionDeclaration,
+      );
       return classState.isLoose ? expr : createClassHelper([expr]);
     }
 
-    let returnArg = t.cloneNode(classState.classRef);
+    let returnArg: t.Expression = t.cloneNode(classState.classRef);
     if (!classState.pushedCreateClass && !classState.isLoose) {
       returnArg = createClassHelper([returnArg]);
     }
diff --git a/packages/babel-plugin-transform-computed-properties/src/index.ts b/packages/babel-plugin-transform-computed-properties/src/index.ts
index efab06d1fbe2..06b89b7b9b05 100644
--- a/packages/babel-plugin-transform-computed-properties/src/index.ts
+++ b/packages/babel-plugin-transform-computed-properties/src/index.ts
@@ -1,10 +1,21 @@
 import { declare } from "@babel/helper-plugin-utils";
-import { template, types as t } from "@babel/core";
+import { template, types as t, type PluginPass } from "@babel/core";
+import type { Scope } from "@babel/traverse";
 
 export interface Options {
   loose?: boolean;
 }
 
+type PropertyInfo = {
+  scope: Scope;
+  objId: t.Identifier;
+  body: t.Statement[];
+  computedProps: t.ObjectMember[];
+  initPropExpression: t.ObjectExpression;
+  getMutatorId: () => t.Identifier;
+  state: PluginPass;
+};
+
 export default declare((api, options: Options) => {
   api.assertVersion(7);
 
@@ -15,14 +26,21 @@ export default declare((api, options: Options) => {
     ? pushComputedPropsLoose
     : pushComputedPropsSpec;
 
-  const buildMutatorMapAssign = template(`
+  const buildMutatorMapAssign = template.statements(`
     MUTATOR_MAP_REF[KEY] = MUTATOR_MAP_REF[KEY] || {};
     MUTATOR_MAP_REF[KEY].KIND = VALUE;
   `);
 
-  function getValue(prop) {
+  /**
+   * Get value of an object member under object expression.
+   * Returns a function expression if prop is a ObjectMethod.
+   *
+   * @param {t.ObjectMember} prop
+   * @returns t.Expression
+   */
+  function getValue(prop: t.ObjectMember) {
     if (t.isObjectProperty(prop)) {
-      return prop.value;
+      return prop.value as t.Expression;
     } else if (t.isObjectMethod(prop)) {
       return t.functionExpression(
         null,
@@ -34,28 +52,30 @@ export default declare((api, options: Options) => {
     }
   }
 
-  function pushAssign(objId, prop, body) {
-    if (prop.kind === "get" && prop.kind === "set") {
-      pushMutatorDefine(objId, prop);
-    } else {
-      body.push(
-        t.expressionStatement(
-          t.assignmentExpression(
-            "=",
-            t.memberExpression(
-              t.cloneNode(objId),
-              prop.key,
-              prop.computed || t.isLiteral(prop.key),
-            ),
-            // @ts-expect-error todo(flow->ts): double-check type error
-            getValue(prop),
+  function pushAssign(
+    objId: t.Identifier,
+    prop: t.ObjectMember,
+    body: t.Statement[],
+  ) {
+    body.push(
+      t.expressionStatement(
+        t.assignmentExpression(
+          "=",
+          t.memberExpression(
+            t.cloneNode(objId),
+            prop.key,
+            prop.computed || t.isLiteral(prop.key),
           ),
+          getValue(prop),
         ),
-      );
-    }
+      ),
+    );
   }
 
-  function pushMutatorDefine({ body, getMutatorId, scope }, prop) {
+  function pushMutatorDefine(
+    { body, getMutatorId, scope }: PropertyInfo,
+    prop: t.ObjectMethod,
+  ) {
     let key =
       !prop.computed && t.isIdentifier(prop.key)
         ? t.stringLiteral(prop.key.name)
@@ -70,18 +90,21 @@ export default declare((api, options: Options) => {
     }
 
     body.push(
-      ...(buildMutatorMapAssign({
+      ...buildMutatorMapAssign({
         MUTATOR_MAP_REF: getMutatorId(),
         KEY: t.cloneNode(key),
         VALUE: getValue(prop),
         KIND: t.identifier(prop.kind),
-      }) as t.Statement[]),
+      }),
     );
   }
 
-  function pushComputedPropsLoose(info) {
+  function pushComputedPropsLoose(info: PropertyInfo) {
     for (const prop of info.computedProps) {
-      if (prop.kind === "get" || prop.kind === "set") {
+      if (
+        t.isObjectMethod(prop) &&
+        (prop.kind === "get" || prop.kind === "set")
+      ) {
         pushMutatorDefine(info, prop);
       } else {
         pushAssign(t.cloneNode(info.objId), prop, info.body);
@@ -89,20 +112,26 @@ export default declare((api, options: Options) => {
     }
   }
 
-  function pushComputedPropsSpec(info) {
+  function pushComputedPropsSpec(info: PropertyInfo) {
     const { objId, body, computedProps, state } = info;
 
     for (const prop of computedProps) {
-      const key = t.toComputedKey(prop);
+      // PrivateName must not be in ObjectExpression
+      const key = t.toComputedKey(prop) as t.Expression;
 
-      if (prop.kind === "get" || prop.kind === "set") {
+      if (
+        t.isObjectMethod(prop) &&
+        (prop.kind === "get" || prop.kind === "set")
+      ) {
         pushMutatorDefine(info, prop);
       } else {
+        // the value of ObjectProperty in ObjectExpression must be an expression
+        const value = getValue(prop) as t.Expression;
         if (computedProps.length === 1) {
           return t.callExpression(state.addHelper("defineProperty"), [
             info.initPropExpression,
             key,
-            getValue(prop),
+            value,
           ]);
         } else {
           body.push(
@@ -110,7 +139,7 @@ export default declare((api, options: Options) => {
               t.callExpression(state.addHelper("defineProperty"), [
                 t.cloneNode(objId),
                 key,
-                getValue(prop),
+                value,
               ]),
             ),
           );
@@ -137,12 +166,14 @@ export default declare((api, options: Options) => {
           // put all getters/setters into the first object expression as well as all initialisers up
           // to the first computed property
 
-          const initProps = [];
-          const computedProps = [];
+          const initProps: t.ObjectMember[] = [];
+          const computedProps: t.ObjectMember[] = [];
           let foundComputed = false;
 
           for (const prop of node.properties) {
-            // @ts-ignore SpreadElement must not have computed property
+            if (t.isSpreadElement(prop)) {
+              continue;
+            }
             if (prop.computed) {
               foundComputed = true;
             }
@@ -164,7 +195,7 @@ export default declare((api, options: Options) => {
             ]),
           );
 
-          let mutatorRef;
+          let mutatorRef: t.Identifier;
 
           const getMutatorId = function () {
             if (!mutatorRef) {
diff --git a/packages/babel-plugin-transform-destructuring/src/index.ts b/packages/babel-plugin-transform-destructuring/src/index.ts
index 5adeda9e870f..0e5398efe1ec 100644
--- a/packages/babel-plugin-transform-destructuring/src/index.ts
+++ b/packages/babel-plugin-transform-destructuring/src/index.ts
@@ -5,8 +5,10 @@ import {
   convertVariableDeclaration,
   convertAssignmentExpression,
   unshiftForXStatementBody,
+  type DestructuringTransformerNode,
 } from "./util";
 export { buildObjectExcludingKeys, unshiftForXStatementBody } from "./util";
+import type { NodePath } from "@babel/traverse";
 
 /**
  * Test if a VariableDeclaration's declarations contains any Patterns.
@@ -67,7 +69,7 @@ export default declare((api, options: Options) => {
         path.scope.crawl();
       },
 
-      ForXStatement(path) {
+      ForXStatement(path: NodePath<t.ForXStatement>) {
         const { node, scope } = path;
         const left = node.left;
 
@@ -81,7 +83,7 @@ export default declare((api, options: Options) => {
           ]);
 
           path.ensureBlock();
-          const statementBody = (node.body as t.BlockStatement).body;
+          const statementBody = path.node.body.body;
           const nodes = [];
           // todo: the completion of a for statement can only be observed from
           // a do block (or eval that we don't support),
@@ -112,7 +114,7 @@ export default declare((api, options: Options) => {
           t.variableDeclarator(key, null),
         ]);
 
-        const nodes = [];
+        const nodes: DestructuringTransformerNode[] = [];
 
         const destructuring = new DestructuringTransformer({
           kind: left.kind,
@@ -138,7 +140,7 @@ export default declare((api, options: Options) => {
         const ref = scope.generateUidIdentifier("ref");
         node.param = ref;
 
-        const nodes = [];
+        const nodes: DestructuringTransformerNode[] = [];
 
         const destructuring = new DestructuringTransformer({
           kind: "let",
@@ -152,7 +154,7 @@ export default declare((api, options: Options) => {
         });
         destructuring.init(pattern, ref);
 
-        node.body.body = nodes.concat(node.body.body);
+        node.body.body = [...nodes, ...node.body.body];
         scope.crawl();
       },
 
diff --git a/packages/babel-plugin-transform-destructuring/src/util.ts b/packages/babel-plugin-transform-destructuring/src/util.ts
index 5f22b4a86ee5..ed5eba74b185 100644
--- a/packages/babel-plugin-transform-destructuring/src/util.ts
+++ b/packages/babel-plugin-transform-destructuring/src/util.ts
@@ -72,7 +72,7 @@ const arrayUnpackVisitor = (
   }
 };
 
-type DestructuringTransformerNode =
+export type DestructuringTransformerNode =
   | t.VariableDeclaration
   | t.ExpressionStatement
   | t.ReturnStatement;
@@ -302,7 +302,7 @@ export class DestructuringTransformer {
 
     // Replace impure computed key expressions if we have a rest parameter
     if (hasObjectRest(pattern)) {
-      let copiedPattern;
+      let copiedPattern: t.ObjectPattern;
       for (let i = 0; i < pattern.properties.length; i++) {
         const prop = pattern.properties[i];
         if (t.isRestElement(prop)) {
@@ -322,7 +322,7 @@ export class DestructuringTransformer {
             };
           }
           copiedPattern.properties[i] = {
-            ...copiedPattern.properties[i],
+            ...prop,
             key: name,
           };
         }
@@ -589,18 +589,19 @@ export function convertVariableDeclaration(
     const patternId = declar.init;
     const pattern = declar.id;
 
-    const destructuring = new DestructuringTransformer({
-      // @ts-expect-error(todo): avoid internal properties access
-      blockHoist: node._blockHoist,
-      nodes: nodes,
-      scope: scope,
-      kind: node.kind,
-      iterableIsArray,
-      arrayLikeIsIterable,
-      useBuiltIns,
-      objectRestNoSymbols,
-      addHelper,
-    });
+    const destructuring: DestructuringTransformer =
+      new DestructuringTransformer({
+        // @ts-expect-error(todo): avoid internal properties access
+        blockHoist: node._blockHoist,
+        nodes: nodes,
+        scope: scope,
+        kind: node.kind,
+        iterableIsArray,
+        arrayLikeIsIterable,
+        useBuiltIns,
+        objectRestNoSymbols,
+        addHelper,
+      });
 
     if (t.isPattern(pattern)) {
       destructuring.init(pattern, patternId);
@@ -623,19 +624,24 @@ export function convertVariableDeclaration(
   let tail: t.VariableDeclaration | null = null;
   const nodesOut = [];
   for (const node of nodes) {
-    if (tail !== null && t.isVariableDeclaration(node)) {
-      // Create a single compound declarations
-      tail.declarations.push(...node.declarations);
-    } else {
-      // Make sure the original node kind is used for each compound declaration
-      node.kind = nodeKind;
-      // Propagate the original declaration node's location
-      if (!node.loc) {
-        node.loc = nodeLoc;
+    if (t.isVariableDeclaration(node)) {
+      if (tail !== null) {
+        // Create a single compound declarations
+        tail.declarations.push(...node.declarations);
+        continue;
+      } else {
+        // Make sure the original node kind is used for each compound declaration
+        node.kind = nodeKind;
+        tail = node;
       }
-      nodesOut.push(node);
-      tail = t.isVariableDeclaration(node) ? node : null;
+    } else {
+      tail = null;
+    }
+    // Propagate the original declaration node's location
+    if (!node.loc) {
+      node.loc = nodeLoc;
     }
+    nodesOut.push(node);
   }
 
   if (nodesOut.length === 1) {
@@ -656,7 +662,7 @@ export function convertAssignmentExpression(
 ) {
   const { node, scope, parentPath } = path;
 
-  const nodes = [];
+  const nodes: DestructuringTransformerNode[] = [];
 
   const destructuring = new DestructuringTransformer({
     operator: node.operator,
diff --git a/packages/babel-plugin-transform-duplicate-keys/src/index.ts b/packages/babel-plugin-transform-duplicate-keys/src/index.ts
index 654c825ef497..f6491648ae2e 100644
--- a/packages/babel-plugin-transform-duplicate-keys/src/index.ts
+++ b/packages/babel-plugin-transform-duplicate-keys/src/index.ts
@@ -1,7 +1,9 @@
 import { declare } from "@babel/helper-plugin-utils";
 import { types as t } from "@babel/core";
 
-function getName(key) {
+function getName(
+  key: t.Identifier | t.StringLiteral | t.NumericLiteral | t.BigIntLiteral,
+) {
   if (t.isIdentifier(key)) {
     return key.name;
   }
@@ -34,7 +36,14 @@ export default declare(api => {
         const alreadySeenSetters = Object.create(null);
 
         for (const prop of plainProps) {
-          const name = getName(prop.key);
+          const name = getName(
+            // prop must be non-computed
+            prop.key as
+              | t.Identifier
+              | t.StringLiteral
+              | t.NumericLiteral
+              | t.BigIntLiteral,
+          );
           let isDuplicate = false;
           // @ts-ignore prop.kind is not defined in ObjectProperty
           switch (prop.kind) {
diff --git a/packages/babel-plugin-transform-exponentiation-operator/src/index.ts b/packages/babel-plugin-transform-exponentiation-operator/src/index.ts
index 680b8b24e8e0..1d68e9fb40d0 100644
--- a/packages/babel-plugin-transform-exponentiation-operator/src/index.ts
+++ b/packages/babel-plugin-transform-exponentiation-operator/src/index.ts
@@ -14,7 +14,11 @@ export default declare(api => {
       build(left, right) {
         return t.callExpression(
           t.memberExpression(t.identifier("Math"), t.identifier("pow")),
-          [left, right],
+          [
+            // left can be PrivateName only if operator is `"in"`
+            left as t.Expression,
+            right,
+          ],
         );
       },
     }),
diff --git a/packages/babel-plugin-transform-flow-comments/src/index.ts b/packages/babel-plugin-transform-flow-comments/src/index.ts
index 666e2c8f0e11..db0573c27ff2 100644
--- a/packages/babel-plugin-transform-flow-comments/src/index.ts
+++ b/packages/babel-plugin-transform-flow-comments/src/index.ts
@@ -7,7 +7,7 @@ import type { NodePath } from "@babel/traverse";
 export default declare(api => {
   api.assertVersion(7);
 
-  function commentFromString(comment) {
+  function commentFromString(comment: string | t.Comment): t.Comment {
     return typeof comment === "string"
       ? { type: "CommentBlock", value: comment }
       : comment;
@@ -21,12 +21,12 @@ export default declare(api => {
     comments = generateComment(ofPath, optional),
     keepType = false,
   }: {
-    ofPath?;
-    toPath?;
-    where?: string;
-    optional?;
-    comments?;
-    keepType?;
+    ofPath?: NodePath;
+    toPath?: NodePath;
+    where?: t.CommentTypeShorthand;
+    optional?: boolean;
+    comments?: string | t.Comment | (string | t.Comment)[];
+    keepType?: boolean;
   }) {
     if (!toPath?.node) {
       toPath = ofPath.getPrevSibling();
@@ -43,7 +43,7 @@ export default declare(api => {
     if (!Array.isArray(comments)) {
       comments = [comments];
     }
-    comments = comments.map(commentFromString);
+    const newComments = comments.map(commentFromString);
     if (!keepType && ofPath?.node) {
       // Removes the node at `ofPath` while conserving the comments attached
       // to it.
@@ -58,24 +58,28 @@ export default declare(api => {
       if (isSingleChild && leading) {
         parent.addComments("inner", leading);
       }
-      toPath.addComments(where, comments);
+      toPath.addComments(where, newComments);
       ofPath.remove();
       if (isSingleChild && trailing) {
         parent.addComments("inner", trailing);
       }
     } else {
-      toPath.addComments(where, comments);
+      toPath.addComments(where, newComments);
     }
   }
 
-  function wrapInFlowComment(path) {
+  function wrapInFlowComment(path: NodePath) {
     attachComment({
       ofPath: path,
-      comments: generateComment(path, path.parent.optional),
+      comments: generateComment(
+        path,
+        // @ts-ignore
+        path.parent.optional,
+      ),
     });
   }
 
-  function generateComment(path, optional?) {
+  function generateComment(path: NodePath, optional?: boolean | void) {
     let comment = path
       .getSource()
       .replace(/\*-\//g, "*-ESCAPED/")
@@ -85,7 +89,7 @@ export default declare(api => {
     return comment;
   }
 
-  function isTypeImport(importKind) {
+  function isTypeImport(importKind: "type" | "typeof" | "value") {
     return importKind === "type" || importKind === "typeof";
   }
 
@@ -236,7 +240,11 @@ export default declare(api => {
         }
       },
 
-      Flow(path) {
+      Flow(
+        path: NodePath<
+          t.Flow | t.ImportDeclaration | t.ExportDeclaration | t.ImportSpecifier
+        >,
+      ) {
         wrapInFlowComment(path);
       },
 
diff --git a/packages/babel-plugin-transform-flow-strip-types/src/index.ts b/packages/babel-plugin-transform-flow-strip-types/src/index.ts
index 8030a99f9c77..aaffbfc3d6cd 100644
--- a/packages/babel-plugin-transform-flow-strip-types/src/index.ts
+++ b/packages/babel-plugin-transform-flow-strip-types/src/index.ts
@@ -1,6 +1,7 @@
 import { declare } from "@babel/helper-plugin-utils";
 import syntaxFlow from "@babel/plugin-syntax-flow";
 import { types as t } from "@babel/core";
+import type { NodePath } from "@babel/traverse";
 
 export interface Options {
   requireDirective?: boolean;
@@ -75,7 +76,11 @@ export default declare((api, opts: Options) => {
         }
       },
 
-      Flow(path) {
+      Flow(
+        path: NodePath<
+          t.Flow | t.ImportDeclaration | t.ExportDeclaration | t.ImportSpecifier
+        >,
+      ) {
         if (skipStrip) {
           throw path.buildCodeFrameError(
             "A @flow directive is required when using Flow annotations with " +
diff --git a/packages/babel-plugin-transform-for-of/src/index.ts b/packages/babel-plugin-transform-for-of/src/index.ts
index b574640d7c5a..edce0e1baca9 100644
--- a/packages/babel-plugin-transform-for-of/src/index.ts
+++ b/packages/babel-plugin-transform-for-of/src/index.ts
@@ -154,15 +154,17 @@ export default declare((api, options: Options) => {
     ? {
         build: buildForOfNoIteratorClosing,
         helper: "createForOfIteratorHelperLoose",
-        getContainer: nodes => nodes,
+        getContainer: (nodes: t.Statement[]): [t.ForStatement] =>
+          nodes as [t.ForStatement],
       }
     : {
         build: buildForOf,
         helper: "createForOfIteratorHelper",
-        getContainer: nodes => nodes[1].block.body,
+        getContainer: (nodes: t.Statement[]): [t.ForStatement] =>
+          (nodes[1] as t.TryStatement).block.body as [t.ForStatement],
       };
 
-  function _ForOfStatementArray(path) {
+  function _ForOfStatementArray(path: NodePath<t.ForOfStatement>) {
     const { node, scope } = path;
 
     const right = scope.generateUidIdentifierBasedOnNode(node.right, "arr");
@@ -257,6 +259,7 @@ export default declare((api, options: Options) => {
         t.inherits(container[0].body, node.body);
 
         if (t.isLabeledStatement(parent)) {
+          // @ts-expect-error replacing node types
           container[0] = t.labeledStatement(parent.label, container[0]);
 
           path.parentPath.replaceWithMultiple(nodes);
diff --git a/packages/babel-plugin-transform-for-of/src/no-helper-implementation.ts b/packages/babel-plugin-transform-for-of/src/no-helper-implementation.ts
index d84143b6e338..fbf4afc5e8ae 100644
--- a/packages/babel-plugin-transform-for-of/src/no-helper-implementation.ts
+++ b/packages/babel-plugin-transform-for-of/src/no-helper-implementation.ts
@@ -1,10 +1,15 @@
-import { template, types as t } from "@babel/core";
+import { type PluginPass, template, types as t } from "@babel/core";
+import type { NodePath } from "@babel/traverse";
 
 // This is the legacy implementation, which inlines all the code.
 // It must be kept for compatibility reasons.
 // TODO (Babel 8): Remove this code.
 
-export default function transformWithoutHelper(loose, path, state) {
+export default function transformWithoutHelper(
+  loose: boolean | void,
+  path: NodePath<t.ForOfStatement>,
+  state: PluginPass,
+) {
   const pushComputedProps = loose
     ? pushComputedPropsLoose
     : pushComputedPropsSpec;
@@ -13,7 +18,7 @@ export default function transformWithoutHelper(loose, path, state) {
   const build = pushComputedProps(path, state);
   const declar = build.declar;
   const loop = build.loop;
-  const block = loop.body;
+  const block = loop.body as t.BlockStatement;
 
   // ensure that it's a block so we can take all its statements
   path.ensureBlock();
@@ -24,7 +29,7 @@ export default function transformWithoutHelper(loose, path, state) {
   }
 
   // push the rest of the original loop body onto our new body
-  block.body.push(...node.body.body);
+  block.body.push(...(node.body as t.BlockStatement).body);
 
   t.inherits(loop, node);
   t.inherits(loop.body, node.body);
@@ -37,7 +42,7 @@ export default function transformWithoutHelper(loose, path, state) {
   }
 }
 
-const buildForOfLoose = template(`
+const buildForOfLoose = template.statement(`
   for (var LOOP_OBJECT = OBJECT,
           IS_ARRAY = Array.isArray(LOOP_OBJECT),
           INDEX = 0,
@@ -54,7 +59,7 @@ const buildForOfLoose = template(`
   }
 `);
 
-const buildForOf = template(`
+const buildForOf = template.statements(`
   var ITERATOR_COMPLETION = true;
   var ITERATOR_HAD_ERROR_KEY = false;
   var ITERATOR_ERROR_KEY = undefined;
@@ -80,7 +85,10 @@ const buildForOf = template(`
   }
 `);
 
-function pushComputedPropsLoose(path, file) {
+function pushComputedPropsLoose(
+  path: NodePath<t.ForOfStatement>,
+  state: PluginPass,
+) {
   const { node, scope, parent } = path;
   const { left } = node;
   let declar, id, intermediate;
@@ -99,7 +107,7 @@ function pushComputedPropsLoose(path, file) {
       t.variableDeclarator(t.identifier(id.name)),
     ]);
   } else {
-    throw file.buildCodeFrameError(
+    throw state.buildCodeFrameError(
       left,
       `Unknown node type ${left.type} in ForStatement`,
     );
@@ -115,7 +123,7 @@ function pushComputedPropsLoose(path, file) {
     INDEX: scope.generateUidIdentifier("i"),
     ID: id,
     INTERMEDIATE: intermediate,
-  }) as t.Statement;
+  }) as t.ForStatement;
 
   //
   const isLabeledParent = t.isLabeledStatement(parent);
@@ -133,7 +141,10 @@ function pushComputedPropsLoose(path, file) {
   };
 }
 
-function pushComputedPropsSpec(path, file) {
+function pushComputedPropsSpec(
+  path: NodePath<t.ForOfStatement>,
+  state: PluginPass,
+) {
   const { node, scope, parent } = path;
   const left = node.left;
   let declar;
@@ -155,7 +166,7 @@ function pushComputedPropsSpec(path, file) {
       t.variableDeclarator(left.declarations[0].id, stepValue),
     ]);
   } else {
-    throw file.buildCodeFrameError(
+    throw state.buildCodeFrameError(
       left,
       `Unknown node type ${left.type} in ForStatement`,
     );
@@ -174,8 +185,8 @@ function pushComputedPropsSpec(path, file) {
 
   const isLabeledParent = t.isLabeledStatement(parent);
 
-  const tryBody = template[3].block.body;
-  const loop = tryBody[0];
+  const tryBody = (template[3] as t.TryStatement).block.body;
+  const loop = tryBody[0] as t.ForStatement;
 
   if (isLabeledParent) {
     tryBody[0] = t.labeledStatement(parent.label, loop);
diff --git a/packages/babel-plugin-transform-function-name/src/index.ts b/packages/babel-plugin-transform-function-name/src/index.ts
index 7bdae7fca350..35600a9215fc 100644
--- a/packages/babel-plugin-transform-function-name/src/index.ts
+++ b/packages/babel-plugin-transform-function-name/src/index.ts
@@ -25,7 +25,12 @@ export default declare(api => {
       ObjectProperty(path) {
         const value = path.get("value");
         if (value.isFunction()) {
-          const newNode = nameFunction(value, false, supportUnicodeId);
+          const newNode = nameFunction(
+            // @ts-ignore Fixme: should check ArrowFunctionExpression
+            value,
+            false,
+            supportUnicodeId,
+          );
           if (newNode) value.replaceWith(newNode);
         }
       },
diff --git a/packages/babel-plugin-transform-modules-amd/src/index.ts b/packages/babel-plugin-transform-modules-amd/src/index.ts
index a22064354549..b1a5e9f80243 100644
--- a/packages/babel-plugin-transform-modules-amd/src/index.ts
+++ b/packages/babel-plugin-transform-modules-amd/src/index.ts
@@ -2,6 +2,7 @@ import { declare } from "@babel/helper-plugin-utils";
 import {
   isModule,
   rewriteModuleStatementsAndPrepareHeader,
+  type RewriteModuleStatementsAndPrepareHeaderOptions,
   hasExports,
   isSideEffectImport,
   buildNamespaceInitStatements,
@@ -12,33 +13,41 @@ import {
 import { template, types as t } from "@babel/core";
 import { getImportSource } from "babel-plugin-dynamic-import-node/utils";
 import type { PluginOptions } from "@babel/helper-module-transforms";
+import type { NodePath } from "@babel/traverse";
 
-const buildWrapper = template(`
+const buildWrapper = template.statement(`
   define(MODULE_NAME, AMD_ARGUMENTS, function(IMPORT_NAMES) {
   })
 `);
 
-const buildAnonymousWrapper = template(`
+const buildAnonymousWrapper = template.statement(`
   define(["require"], function(REQUIRE) {
   })
 `);
 
-function injectWrapper(path, wrapper) {
+function injectWrapper(
+  path: NodePath<t.Program>,
+  wrapper: t.ExpressionStatement,
+) {
   const { body, directives } = path.node;
   path.node.directives = [];
   path.node.body = [];
-  const amdWrapper = path.pushContainer("body", wrapper)[0];
-  const amdFactory = amdWrapper
-    .get("expression.arguments")
-    .filter(arg => arg.isFunctionExpression())[0]
-    .get("body");
+  const amdFactoryCall = path
+    .pushContainer("body", wrapper)[0]
+    .get("expression") as NodePath<t.CallExpression>;
+  const amdFactoryCallArgs = amdFactoryCall.get("arguments");
+  const amdFactory = (
+    amdFactoryCallArgs[
+      amdFactoryCallArgs.length - 1
+    ] as NodePath<t.FunctionExpression>
+  ).get("body") as NodePath<t.BlockStatement>;
   amdFactory.pushContainer("directives", directives);
   amdFactory.pushContainer("body", body);
 }
 
 export interface Options extends PluginOptions {
   allowTopLevelThis?: boolean;
-  importInterop?: "babel" | "node";
+  importInterop?: RewriteModuleStatementsAndPrepareHeaderOptions["importInterop"];
   loose?: boolean;
   noInterop?: boolean;
   strict?: boolean;
@@ -107,7 +116,9 @@ export default declare<State>((api, options: Options) => {
             if (requireId) {
               injectWrapper(
                 path,
-                buildAnonymousWrapper({ REQUIRE: t.cloneNode(requireId) }),
+                buildAnonymousWrapper({
+                  REQUIRE: t.cloneNode(requireId),
+                }) as t.ExpressionStatement,
               );
             }
             return;
@@ -186,7 +197,7 @@ export default declare<State>((api, options: Options) => {
 
               AMD_ARGUMENTS: t.arrayExpression(amdArgs),
               IMPORT_NAMES: importNames,
-            }),
+            }) as t.ExpressionStatement,
           );
         },
       },
diff --git a/packages/babel-plugin-transform-modules-commonjs/src/index.ts b/packages/babel-plugin-transform-modules-commonjs/src/index.ts
index e3de86a846b6..d15f31c4e0a6 100644
--- a/packages/babel-plugin-transform-modules-commonjs/src/index.ts
+++ b/packages/babel-plugin-transform-modules-commonjs/src/index.ts
@@ -2,6 +2,7 @@ import { declare } from "@babel/helper-plugin-utils";
 import {
   isModule,
   rewriteModuleStatementsAndPrepareHeader,
+  type RewriteModuleStatementsAndPrepareHeaderOptions,
   isSideEffectImport,
   buildNamespaceInitStatements,
   ensureStatementsHoisted,
@@ -18,8 +19,8 @@ import { createDynamicImportTransform } from "babel-plugin-dynamic-import-node/u
 export interface Options extends PluginOptions {
   allowCommonJSExports?: boolean;
   allowTopLevelThis?: boolean;
-  importInterop?: "babel" | "node";
-  lazy?: boolean | string[] | ((string) => boolean);
+  importInterop?: RewriteModuleStatementsAndPrepareHeaderOptions["importInterop"];
+  lazy?: RewriteModuleStatementsAndPrepareHeaderOptions["lazy"];
   loose?: boolean;
   mjsStrictNamespace?: boolean;
   noInterop?: boolean;
@@ -74,7 +75,7 @@ export default declare((api, options: Options) => {
     throw new Error(`.mjsStrictNamespace must be a boolean, or undefined`);
   }
 
-  const getAssertion = localName => template.expression.ast`
+  const getAssertion = (localName: string) => template.expression.ast`
     (function(){
       throw new Error(
         "The CommonJS '" + "${localName}" + "' variable is not available in ES6 modules." +
@@ -236,7 +237,7 @@ export default declare((api, options: Options) => {
               t.stringLiteral(source),
             ]);
 
-            let header;
+            let header: t.Statement;
             if (isSideEffectImport(metadata)) {
               if (metadata.lazy) throw new Error("Assertion failure");
 
@@ -246,7 +247,7 @@ export default declare((api, options: Options) => {
                 wrapInterop(path, loadExpr, metadata.interop) || loadExpr;
 
               if (metadata.lazy) {
-                header = template.ast`
+                header = template.statement.ast`
                   function ${metadata.name}() {
                     const data = ${init};
                     ${metadata.name} = function(){ return data; };
@@ -254,7 +255,7 @@ export default declare((api, options: Options) => {
                   }
                 `;
               } else {
-                header = template.ast`
+                header = template.statement.ast`
                   var ${metadata.name} = ${init};
                 `;
               }
diff --git a/packages/babel-plugin-transform-modules-systemjs/src/index.ts b/packages/babel-plugin-transform-modules-systemjs/src/index.ts
index 30832c80f833..1453fb694540 100644
--- a/packages/babel-plugin-transform-modules-systemjs/src/index.ts
+++ b/packages/babel-plugin-transform-modules-systemjs/src/index.ts
@@ -72,12 +72,18 @@ type PluginState = {
   stringSpecifiers: Set<string>;
 };
 
+type ModuleMetadata = {
+  key: string;
+  imports: any[];
+  exports: any[];
+};
+
 function constructExportCall(
-  path,
-  exportIdent,
-  exportNames,
-  exportValues,
-  exportStarTarget,
+  path: NodePath<t.Program>,
+  exportIdent: t.Identifier,
+  exportNames: string[],
+  exportValues: t.Expression[],
+  exportStarTarget: t.Identifier | null,
   stringSpecifiers: Set<string>,
 ) {
   const statements = [];
@@ -312,27 +318,31 @@ export default declare<PluginState>((api, options: Options) => {
             rewriteThis(path);
           }
         },
-        exit(path: NodePath<t.Program>, state: PluginState) {
+        exit(path, state) {
           const scope = path.scope;
           const exportIdent = scope.generateUid("export");
           const { contextIdent, stringSpecifiers } = state;
 
-          const exportMap = Object.create(null);
-          const modules = [];
+          const exportMap: Record<string, string[]> = Object.create(null);
+          const modules: ModuleMetadata[] = [];
 
           const beforeBody = [];
-          const setters = [];
-          const sources = [];
+          const setters: t.Expression[] = [];
+          const sources: t.StringLiteral[] = [];
           const variableIds = [];
           const removedPaths = [];
 
-          function addExportName(key, val) {
+          function addExportName(key: string, val: string) {
             exportMap[key] = exportMap[key] || [];
             exportMap[key].push(val);
           }
 
-          function pushModule(source, key, specifiers) {
-            let module;
+          function pushModule(
+            source: string,
+            key: "imports" | "exports",
+            specifiers: t.ModuleSpecifier[] | t.ExportAllDeclaration,
+          ) {
+            let module: ModuleMetadata;
             modules.forEach(function (m) {
               if (m.key === source) {
                 module = m;
@@ -346,7 +356,7 @@ export default declare<PluginState>((api, options: Options) => {
             module[key] = module[key].concat(specifiers);
           }
 
-          function buildExportCall(name, val) {
+          function buildExportCall(name: string, val: t.Expression) {
             return t.expressionStatement(
               t.callExpression(t.identifier(exportIdent), [
                 t.stringLiteral(name),
@@ -356,7 +366,7 @@ export default declare<PluginState>((api, options: Options) => {
           }
 
           const exportNames = [];
-          const exportValues = [];
+          const exportValues: t.Expression[] = [];
 
           const body = path.get("body");
 
@@ -391,9 +401,9 @@ export default declare<PluginState>((api, options: Options) => {
               pushModule(path.node.source.value, "exports", path.node);
               path.remove();
             } else if (path.isExportDefaultDeclaration()) {
-              const declar = path.get("declaration");
-              if (declar.isClassDeclaration()) {
-                const id = declar.node.id;
+              const declar = path.node.declaration;
+              if (t.isClassDeclaration(declar)) {
+                const id = declar.id;
                 if (id) {
                   exportNames.push("default");
                   exportValues.push(scope.buildUndefinedNode());
@@ -404,67 +414,66 @@ export default declare<PluginState>((api, options: Options) => {
                       t.assignmentExpression(
                         "=",
                         t.cloneNode(id),
-                        t.toExpression(declar.node),
+                        t.toExpression(declar),
                       ),
                     ),
                   );
                 } else {
                   exportNames.push("default");
-                  exportValues.push(t.toExpression(declar.node));
+                  exportValues.push(t.toExpression(declar));
                   removedPaths.push(path);
                 }
-              } else if (declar.isFunctionDeclaration()) {
-                const id = declar.node.id;
+              } else if (t.isFunctionDeclaration(declar)) {
+                const id = declar.id;
                 if (id) {
-                  beforeBody.push(declar.node);
+                  beforeBody.push(declar);
                   exportNames.push("default");
                   exportValues.push(t.cloneNode(id));
                   addExportName(id.name, "default");
                 } else {
                   exportNames.push("default");
-                  exportValues.push(t.toExpression(declar.node));
+                  exportValues.push(t.toExpression(declar));
                 }
                 removedPaths.push(path);
               } else {
-                path.replaceWith(buildExportCall("default", declar.node));
+                path.replaceWith(buildExportCall("default", declar));
               }
             } else if (path.isExportNamedDeclaration()) {
-              const declar = path.get("declaration");
+              const declar = path.node.declaration;
 
-              if (declar.node) {
+              if (declar) {
                 path.replaceWith(declar);
 
-                if (declar.isFunction()) {
-                  const node = declar.node;
-                  const name = node.id.name;
+                if (t.isFunction(declar)) {
+                  const name = declar.id.name;
                   addExportName(name, name);
-                  beforeBody.push(node);
+                  beforeBody.push(declar);
                   exportNames.push(name);
-                  exportValues.push(t.cloneNode(node.id));
+                  exportValues.push(t.cloneNode(declar.id));
                   removedPaths.push(path);
-                } else if (declar.isClass()) {
-                  const name = declar.node.id.name;
+                } else if (t.isClass(declar)) {
+                  const name = declar.id.name;
                   exportNames.push(name);
                   exportValues.push(scope.buildUndefinedNode());
-                  variableIds.push(t.cloneNode(declar.node.id));
+                  variableIds.push(t.cloneNode(declar.id));
                   path.replaceWith(
                     t.expressionStatement(
                       t.assignmentExpression(
                         "=",
-                        t.cloneNode(declar.node.id),
-                        t.toExpression(declar.node),
+                        t.cloneNode(declar.id),
+                        t.toExpression(declar),
                       ),
                     ),
                   );
                   addExportName(name, name);
                 } else {
-                  if (declar.isVariableDeclaration()) {
+                  if (t.isVariableDeclaration(declar)) {
                     // Convert top-level variable declarations to "var",
                     // because they must be hoisted
-                    declar.node.kind = "var";
+                    declar.kind = "var";
                   }
                   for (const name of Object.keys(
-                    declar.getBindingIdentifiers(),
+                    t.getBindingIdentifiers(declar),
                   )) {
                     addExportName(name, name);
                   }
diff --git a/packages/babel-plugin-transform-modules-umd/src/index.ts b/packages/babel-plugin-transform-modules-umd/src/index.ts
index 955e23ac9ee4..183eedb4895e 100644
--- a/packages/babel-plugin-transform-modules-umd/src/index.ts
+++ b/packages/babel-plugin-transform-modules-umd/src/index.ts
@@ -3,6 +3,7 @@ import { basename, extname } from "path";
 import {
   isModule,
   rewriteModuleStatementsAndPrepareHeader,
+  type RewriteModuleStatementsAndPrepareHeaderOptions,
   hasExports,
   isSideEffectImport,
   buildNamespaceInitStatements,
@@ -44,7 +45,7 @@ export interface Options extends PluginOptions {
   allowTopLevelThis?: boolean;
   exactGlobals?: boolean;
   globals?: Record<string, string>;
-  importInterop?: "babel" | "node";
+  importInterop?: RewriteModuleStatementsAndPrepareHeaderOptions["importInterop"];
   loose?: boolean;
   noInterop?: boolean;
   strict?: boolean;
@@ -73,10 +74,10 @@ export default declare((api, options: Options) => {
    * Build the assignment statements that initialize the UMD global.
    */
   function buildBrowserInit(
-    browserGlobals,
-    exactGlobals,
-    filename,
-    moduleName,
+    browserGlobals: Record<string, string>,
+    exactGlobals: boolean,
+    filename: string,
+    moduleName: t.StringLiteral | void,
   ) {
     const moduleNameOrBasename = moduleName
       ? moduleName.value
@@ -121,17 +122,22 @@ export default declare((api, options: Options) => {
   /**
    * Build the member expression that reads from a global for a given source.
    */
-  function buildBrowserArg(browserGlobals, exactGlobals, source) {
-    let memberExpression;
+  function buildBrowserArg(
+    browserGlobals: Record<string, string>,
+    exactGlobals: boolean,
+    source: string,
+  ) {
+    let memberExpression: t.MemberExpression;
     if (exactGlobals) {
       const globalRef = browserGlobals[source];
       if (globalRef) {
         memberExpression = globalRef
           .split(".")
           .reduce(
-            (accum, curr) => t.memberExpression(accum, t.identifier(curr)),
+            (accum: t.Identifier | t.MemberExpression, curr) =>
+              t.memberExpression(accum, t.identifier(curr)),
             t.identifier("global"),
-          );
+          ) as t.MemberExpression;
       } else {
         memberExpression = t.memberExpression(
           t.identifier("global"),
@@ -159,9 +165,9 @@ export default declare((api, options: Options) => {
 
           const browserGlobals = globals || {};
 
-          let moduleName = getModuleName(this.file.opts, options);
-          // @ts-expect-error todo(flow->ts): do not reuse variables
-          if (moduleName) moduleName = t.stringLiteral(moduleName);
+          const moduleName = getModuleName(this.file.opts, options);
+          let moduleNameLiteral: void | t.StringLiteral;
+          if (moduleName) moduleNameLiteral = t.stringLiteral(moduleName);
 
           const { meta, headers } = rewriteModuleStatementsAndPrepareHeader(
             path,
@@ -240,7 +246,8 @@ export default declare((api, options: Options) => {
           path.node.body = [];
           const umdWrapper = path.pushContainer("body", [
             buildWrapper({
-              MODULE_NAME: moduleName,
+              //todo: buildWrapper does not handle void moduleNameLiteral
+              MODULE_NAME: moduleNameLiteral,
 
               AMD_ARGUMENTS: t.arrayExpression(amdArgs),
               COMMONJS_ARGUMENTS: commonjsArgs,
@@ -251,13 +258,13 @@ export default declare((api, options: Options) => {
                 browserGlobals,
                 exactGlobals,
                 this.filename || "unknown",
-                moduleName,
+                moduleNameLiteral,
               ),
             }) as t.Statement,
           ])[0] as NodePath<t.ExpressionStatement>;
           const umdFactory = (
             umdWrapper.get("expression.arguments")[1] as NodePath<t.Function>
-          ).get("body");
+          ).get("body") as NodePath<t.BlockStatement>;
           umdFactory.pushContainer("directives", directives);
           umdFactory.pushContainer("body", body);
         },
diff --git a/packages/babel-plugin-transform-object-super/src/index.ts b/packages/babel-plugin-transform-object-super/src/index.ts
index b375f575f92f..86df844f2cf1 100644
--- a/packages/babel-plugin-transform-object-super/src/index.ts
+++ b/packages/babel-plugin-transform-object-super/src/index.ts
@@ -1,8 +1,13 @@
 import { declare } from "@babel/helper-plugin-utils";
 import ReplaceSupers from "@babel/helper-replace-supers";
-import { types as t } from "@babel/core";
-
-function replacePropertySuper(path, getObjectRef, file) {
+import { types as t, type File } from "@babel/core";
+import type { NodePath } from "@babel/traverse";
+
+function replacePropertySuper(
+  path: NodePath<t.ObjectMethod>,
+  getObjectRef: () => t.Identifier,
+  file: File,
+) {
   // @ts-expect-error todo(flow->ts):
   const replaceSupers = new ReplaceSupers({
     getObjectRef: getObjectRef,
@@ -21,14 +26,14 @@ export default declare(api => {
 
     visitor: {
       ObjectExpression(path, state) {
-        let objectRef;
+        let objectRef: t.Identifier;
         const getObjectRef = () =>
           (objectRef = objectRef || path.scope.generateUidIdentifier("obj"));
 
         path.get("properties").forEach(propPath => {
           if (!propPath.isMethod()) return;
 
-          replacePropertySuper(propPath, getObjectRef, state);
+          replacePropertySuper(propPath, getObjectRef, state.file);
         });
 
         if (objectRef) {
diff --git a/packages/babel-plugin-transform-parameters/src/params.ts b/packages/babel-plugin-transform-parameters/src/params.ts
index d9bfd15af987..9b21a95952ad 100644
--- a/packages/babel-plugin-transform-parameters/src/params.ts
+++ b/packages/babel-plugin-transform-parameters/src/params.ts
@@ -1,6 +1,7 @@
 import { template, types as t } from "@babel/core";
+import type { NodePath, Scope, Visitor } from "@babel/traverse";
 
-const buildDefaultParam = template(`
+const buildDefaultParam = template.statement(`
   let VARIABLE_NAME =
     arguments.length > ARGUMENT_KEY && arguments[ARGUMENT_KEY] !== undefined ?
       arguments[ARGUMENT_KEY]
@@ -8,22 +9,25 @@ const buildDefaultParam = template(`
       DEFAULT_VALUE;
 `);
 
-const buildLooseDefaultParam = template(`
+const buildLooseDefaultParam = template.statement(`
   if (ASSIGNMENT_IDENTIFIER === UNDEFINED) {
     ASSIGNMENT_IDENTIFIER = DEFAULT_VALUE;
   }
 `);
 
-const buildLooseDestructuredDefaultParam = template(`
+const buildLooseDestructuredDefaultParam = template.statement(`
   let ASSIGNMENT_IDENTIFIER = PARAMETER_NAME === UNDEFINED ? DEFAULT_VALUE : PARAMETER_NAME ;
 `);
 
-const buildSafeArgumentsAccess = template(`
+const buildSafeArgumentsAccess = template.statement(`
   let $0 = arguments.length > $1 ? arguments[$1] : undefined;
 `);
 
-const iifeVisitor = {
-  "ReferencedIdentifier|BindingIdentifier"(path, state) {
+const iifeVisitor: Visitor<State> = {
+  "ReferencedIdentifier|BindingIdentifier"(
+    path: NodePath<t.Identifier>,
+    state,
+  ) {
     const { scope, node } = path;
     const { name } = node;
 
@@ -38,15 +42,25 @@ const iifeVisitor = {
   },
   // type annotations don't use or introduce "real" bindings
   "TypeAnnotation|TSTypeAnnotation|TypeParameterDeclaration|TSTypeParameterDeclaration":
-    path => path.skip(),
+    (path: NodePath) => path.skip(),
+};
+
+type State = {
+  stop: boolean;
+  needsOuterBinding: boolean;
+  scope: Scope;
 };
 
 // last 2 parameters are optional -- they are used by proposal-object-rest-spread/src/index.js
 export default function convertFunctionParams(
-  path,
-  ignoreFunctionLength,
-  shouldTransformParam?,
-  replaceRestElement?,
+  path: NodePath<t.Function>,
+  ignoreFunctionLength: boolean | void,
+  shouldTransformParam?: (index: number) => boolean,
+  replaceRestElement?: (
+    path: NodePath<t.Function>,
+    paramPath: NodePath<t.Function["params"][number]>,
+    transformedRestNodes: t.Statement[],
+  ) => void,
 ) {
   const params = path.get("params");
 
@@ -62,7 +76,7 @@ export default function convertFunctionParams(
   };
 
   const body = [];
-  const shadowedParams = new Set();
+  const shadowedParams = new Set<string>();
 
   for (const param of params) {
     for (const name of Object.keys(param.getBindingIdentifiers())) {
@@ -117,15 +131,15 @@ export default function convertFunctionParams(
     if (shouldTransformParam && !shouldTransformParam(i)) {
       continue;
     }
-    const transformedRestNodes = [];
+    const transformedRestNodes: t.Statement[] = [];
     if (replaceRestElement) {
-      replaceRestElement(param.parentPath, param, transformedRestNodes);
+      replaceRestElement(path, param, transformedRestNodes);
     }
 
     const paramIsAssignmentPattern = param.isAssignmentPattern();
     if (
       paramIsAssignmentPattern &&
-      (ignoreFunctionLength || node.kind === "set")
+      (ignoreFunctionLength || t.isMethod(node, { kind: "set" }))
     ) {
       const left = param.get("left");
       const right = param.get("right");
@@ -198,14 +212,21 @@ export default function convertFunctionParams(
   path.ensureBlock();
 
   if (state.needsOuterBinding || shadowedParams.size > 0) {
-    body.push(buildScopeIIFE(shadowedParams, path.get("body").node));
+    body.push(
+      buildScopeIIFE(
+        shadowedParams,
+        (path.get("body") as NodePath<t.BlockStatement>).node,
+      ),
+    );
 
-    path.set("body", t.blockStatement(body));
+    path.set("body", t.blockStatement(body as t.Statement[]));
 
     // We inject an arrow and then transform it to a normal function, to be
     // sure that we correctly handle this and arguments.
-    const bodyPath = path.get("body.body");
-    const arrowPath = bodyPath[bodyPath.length - 1].get("argument.callee");
+    const bodyPath = path.get("body.body") as NodePath<t.Statement>[];
+    const arrowPath = bodyPath[bodyPath.length - 1].get(
+      "argument.callee",
+    ) as NodePath<t.ArrowFunctionExpression>;
 
     // This is an IIFE, so we don't need to worry about the noNewArrows assumption
     arrowPath.arrowFunctionToExpression();
@@ -223,7 +244,7 @@ export default function convertFunctionParams(
   return true;
 }
 
-function buildScopeIIFE(shadowedParams, body) {
+function buildScopeIIFE(shadowedParams: Set<string>, body: t.BlockStatement) {
   const args = [];
   const params = [];
 
diff --git a/packages/babel-plugin-transform-parameters/src/rest.ts b/packages/babel-plugin-transform-parameters/src/rest.ts
index 3d784f58b024..7087a936bac2 100644
--- a/packages/babel-plugin-transform-parameters/src/rest.ts
+++ b/packages/babel-plugin-transform-parameters/src/rest.ts
@@ -1,6 +1,7 @@
 import { template, types as t } from "@babel/core";
+import type { NodePath, Visitor } from "@babel/traverse";
 
-const buildRest = template(`
+const buildRest = template.statement(`
   for (var LEN = ARGUMENTS.length,
            ARRAY = new Array(ARRAY_LEN),
            KEY = START;
@@ -10,19 +11,22 @@ const buildRest = template(`
   }
 `);
 
-const restIndex = template(`
+const restIndex = template.expression(`
   (INDEX < OFFSET || ARGUMENTS.length <= INDEX) ? undefined : ARGUMENTS[INDEX]
 `);
 
-const restIndexImpure = template(`
+const restIndexImpure = template.expression(`
   REF = INDEX, (REF < OFFSET || ARGUMENTS.length <= REF) ? undefined : ARGUMENTS[REF]
 `);
 
-const restLength = template(`
+const restLength = template.expression(`
   ARGUMENTS.length <= OFFSET ? 0 : ARGUMENTS.length - OFFSET
 `);
 
-function referencesRest(path, state) {
+function referencesRest(
+  path: NodePath<t.Identifier | t.JSXIdentifier>,
+  state: State,
+) {
   if (path.node.name === state.name) {
     // Check rest parameter is not shadowed by a binding in another scope.
     return path.scope.bindingIdentifierEquals(state.name, state.outerBinding);
@@ -31,7 +35,41 @@ function referencesRest(path, state) {
   return false;
 }
 
-const memberExpressionOptimisationVisitor = {
+type Candidate = {
+  cause: "argSpread" | "indexGetter" | "lengthGetter";
+  path: NodePath<t.Identifier | t.JSXIdentifier>;
+};
+
+type State = {
+  references: NodePath<t.Identifier | t.JSXIdentifier>[];
+  offset: number;
+
+  argumentsNode: t.Identifier;
+  outerBinding: t.Identifier;
+
+  // candidate member expressions we could optimise if there are no other references
+  candidates: Candidate[];
+
+  // local rest binding name
+  name: string;
+
+  /*
+  It may be possible to optimize the output code in certain ways, such as
+  not generating code to initialize an array (perhaps substituting direct
+  references to arguments[i] or arguments.length for reads of the
+  corresponding rest parameter property) or positioning the initialization
+  code so that it may not have to execute depending on runtime conditions.
+
+  This property tracks eligibility for optimization. "deopted" means give up
+  and don't perform optimization. For example, when any of rest's elements /
+  properties is assigned to at the top level, or referenced at all in a
+  nested function.
+  */
+  deopted: boolean;
+  noOptimise?: boolean;
+};
+
+const memberExpressionOptimisationVisitor: Visitor<State> = {
   Scope(path, state) {
     // check if this scope has a local binding that will shadow the rest parameter
     if (!path.scope.bindingIdentifierEquals(state.name, state.outerBinding)) {
@@ -39,7 +77,7 @@ const memberExpressionOptimisationVisitor = {
     }
   },
 
-  Flow(path) {
+  Flow(path: NodePath<t.Flow>) {
     // Do not skip TypeCastExpressions as the contain valid non flow code
     if (path.isTypeCastExpression()) return;
     // don't touch reference in type annotations
@@ -119,7 +157,10 @@ const memberExpressionOptimisationVisitor = {
               state.candidates.push({ cause: "indexGetter", path });
               return;
             }
-          } else if (parentPath.node.property.name === "length") {
+          } else if (
+            // @ts-expect-error .length must not be a private name
+            parentPath.node.property.name === "length"
+          ) {
             // args.length
             state.candidates.push({ cause: "lengthGetter", path });
             return;
@@ -156,7 +197,7 @@ const memberExpressionOptimisationVisitor = {
   },
 };
 
-function getParamsCount(node) {
+function getParamsCount(node: t.Function) {
   let count = node.params.length;
   // skip the first parameter if it is a TypeScript 'this parameter'
   if (count > 0 && t.isIdentifier(node.params[0], { name: "this" })) {
@@ -165,33 +206,38 @@ function getParamsCount(node) {
   return count;
 }
 
-function hasRest(node) {
+function hasRest(node: t.Function) {
   const length = node.params.length;
   return length > 0 && t.isRestElement(node.params[length - 1]);
 }
 
-function optimiseIndexGetter(path, argsId, offset) {
+function optimiseIndexGetter(
+  path: NodePath<t.Identifier | t.JSXIdentifier>,
+  argsId: t.Identifier,
+  offset: number,
+) {
   const offsetLiteral = t.numericLiteral(offset);
   let index;
+  const parent = path.parent as t.MemberExpression;
 
-  if (t.isNumericLiteral(path.parent.property)) {
-    index = t.numericLiteral(path.parent.property.value + offset);
+  if (t.isNumericLiteral(parent.property)) {
+    index = t.numericLiteral(parent.property.value + offset);
   } else if (offset === 0) {
     // Avoid unnecessary '+ 0'
-    index = path.parent.property;
+    index = parent.property;
   } else {
     index = t.binaryExpression(
       "+",
-      path.parent.property,
+      parent.property,
       t.cloneNode(offsetLiteral),
     );
   }
 
-  const { scope } = path;
+  const { scope, parentPath } = path;
   if (!scope.isPure(index)) {
     const temp = scope.generateUidIdentifierBasedOnNode(index);
     scope.push({ id: temp, kind: "var" });
-    path.parentPath.replaceWith(
+    parentPath.replaceWith(
       restIndexImpure({
         ARGUMENTS: argsId,
         OFFSET: offsetLiteral,
@@ -200,7 +246,6 @@ function optimiseIndexGetter(path, argsId, offset) {
       }),
     );
   } else {
-    const parentPath = path.parentPath;
     parentPath.replaceWith(
       restIndex({
         ARGUMENTS: argsId,
@@ -208,22 +253,29 @@ function optimiseIndexGetter(path, argsId, offset) {
         INDEX: index,
       }),
     );
+    const replacedParentPath = parentPath as NodePath<t.ConditionalExpression>;
 
     // See if we can statically evaluate the first test (i.e. index < offset)
     // and optimize the AST accordingly.
-    const offsetTestPath = parentPath.get("test").get("left");
-    const valRes = offsetTestPath.evaluate();
+    const offsetTestPath = replacedParentPath.get(
+      "test",
+    ) as NodePath<t.BinaryExpression>;
+    const valRes = offsetTestPath.get("left").evaluate();
     if (valRes.confident) {
       if (valRes.value === true) {
-        parentPath.replaceWith(parentPath.scope.buildUndefinedNode());
+        replacedParentPath.replaceWith(scope.buildUndefinedNode());
       } else {
-        parentPath.get("test").replaceWith(parentPath.get("test").get("right"));
+        offsetTestPath.replaceWith(offsetTestPath.get("right"));
       }
     }
   }
 }
 
-function optimiseLengthGetter(path, argsId, offset) {
+function optimiseLengthGetter(
+  path: NodePath<t.Identifier | t.JSXIdentifier>,
+  argsId: t.Identifier,
+  offset: number,
+) {
   if (offset) {
     path.parentPath.replaceWith(
       restLength({
@@ -236,15 +288,13 @@ function optimiseLengthGetter(path, argsId, offset) {
   }
 }
 
-export default function convertFunctionRest(path) {
+export default function convertFunctionRest(path: NodePath<t.Function>) {
   const { node, scope } = path;
   if (!hasRest(node)) return false;
 
-  let rest = node.params.pop().argument;
-
-  if (rest.name === "arguments") scope.rename(rest.name);
-
-  const argsId = t.identifier("arguments");
+  let rest = (node.params.pop() as t.RestElement).argument as
+    | t.Pattern
+    | t.Identifier;
 
   if (t.isPattern(rest)) {
     const pattern = rest;
@@ -253,37 +303,23 @@ export default function convertFunctionRest(path) {
     const declar = t.variableDeclaration("let", [
       t.variableDeclarator(pattern, rest),
     ]);
-    node.body.body.unshift(declar);
+    path.ensureBlock();
+    (node.body as t.BlockStatement).body.unshift(declar);
+  } else if (rest.name === "arguments") {
+    scope.rename(rest.name);
   }
 
+  const argsId = t.identifier("arguments");
   const paramsCount = getParamsCount(node);
 
   // check and optimise for extremely common cases
-  const state = {
+  const state: State = {
     references: [],
     offset: paramsCount,
-
     argumentsNode: argsId,
     outerBinding: scope.getBindingIdentifier(rest.name),
-
-    // candidate member expressions we could optimise if there are no other references
     candidates: [],
-
-    // local rest binding name
     name: rest.name,
-
-    /*
-    It may be possible to optimize the output code in certain ways, such as
-    not generating code to initialize an array (perhaps substituting direct
-    references to arguments[i] or arguments.length for reads of the
-    corresponding rest parameter property) or positioning the initialization
-    code so that it may not have to execute depending on runtime conditions.
-
-    This property tracks eligibility for optimization. "deopted" means give up
-    and don't perform optimization. For example, when any of rest's elements /
-    properties is assigned to at the top level, or referenced at all in a
-    nested function.
-    */
     deopted: false,
   };
 
@@ -347,7 +383,7 @@ export default function convertFunctionRest(path) {
   });
 
   if (state.deopted) {
-    node.body.body.unshift(loop);
+    (node.body as t.BlockStatement).body.unshift(loop);
   } else {
     let target = path
       .getEarliestCommonAncestorFrom(state.references)
diff --git a/packages/babel-plugin-transform-property-mutators/src/index.ts b/packages/babel-plugin-transform-property-mutators/src/index.ts
index 8323bda0acfe..abfff41b10c1 100644
--- a/packages/babel-plugin-transform-property-mutators/src/index.ts
+++ b/packages/babel-plugin-transform-property-mutators/src/index.ts
@@ -9,9 +9,9 @@ export default declare(api => {
     name: "transform-property-mutators",
 
     visitor: {
-      ObjectExpression(path, file) {
+      ObjectExpression(path, { file }) {
         const { node } = path;
-        let mutatorMap;
+        let mutatorMap: defineMap.MutatorMap | void;
         const newProperties = node.properties.filter(function (prop) {
           if (t.isObjectMethod(prop)) {
             if (prop.kind === "get" || prop.kind === "set") {
diff --git a/packages/babel-plugin-transform-proto-to-assign/src/index.ts b/packages/babel-plugin-transform-proto-to-assign/src/index.ts
index bd29c5933ff2..1bd61aeeb755 100644
--- a/packages/babel-plugin-transform-proto-to-assign/src/index.ts
+++ b/packages/babel-plugin-transform-proto-to-assign/src/index.ts
@@ -1,22 +1,35 @@
 import { declare } from "@babel/helper-plugin-utils";
-import { types as t } from "@babel/core";
+import { types as t, type File } from "@babel/core";
 
 export default declare(api => {
   api.assertVersion(7);
 
-  function isProtoKey(node) {
-    return t.isLiteral(t.toComputedKey(node, node.key), { value: "__proto__" });
+  function isProtoKey(node: t.ObjectExpression["properties"][number]) {
+    return (
+      !t.isSpreadElement(node) &&
+      t.isStringLiteral(t.toComputedKey(node, node.key), {
+        value: "__proto__",
+      })
+    );
   }
 
-  function isProtoAssignmentExpression(node): node is t.MemberExpression {
+  function isProtoAssignmentExpression(
+    node: t.Node,
+  ): node is t.MemberExpression {
     const left = node;
     return (
       t.isMemberExpression(left) &&
-      t.isLiteral(t.toComputedKey(left, left.property), { value: "__proto__" })
+      t.isStringLiteral(t.toComputedKey(left, left.property), {
+        value: "__proto__",
+      })
     );
   }
 
-  function buildDefaultsCallExpression(expr, ref, file) {
+  function buildDefaultsCallExpression(
+    expr: t.AssignmentExpression,
+    ref: t.MemberExpression["object"],
+    file: File,
+  ) {
     return t.expressionStatement(
       t.callExpression(file.addHelper("defaults"), [ref, expr.right]),
     );
@@ -26,7 +39,7 @@ export default declare(api => {
     name: "transform-proto-to-assign",
 
     visitor: {
-      AssignmentExpression(path, file) {
+      AssignmentExpression(path, { file }) {
         if (!isProtoAssignmentExpression(path.node.left)) return;
 
         const nodes = [];
@@ -50,7 +63,7 @@ export default declare(api => {
         path.replaceWithMultiple(nodes);
       },
 
-      ExpressionStatement(path, file) {
+      ExpressionStatement(path, { file }) {
         const expr = path.node.expression;
         if (!t.isAssignmentExpression(expr, { operator: "=" })) return;
 
@@ -61,7 +74,7 @@ export default declare(api => {
         }
       },
 
-      ObjectExpression(path, file) {
+      ObjectExpression(path, { file }) {
         let proto;
         const { node } = path;
         const { properties } = node;
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 c759d49e6533..bc1a89f3fe0b 100644
--- a/packages/babel-plugin-transform-react-constant-elements/src/index.ts
+++ b/packages/babel-plugin-transform-react-constant-elements/src/index.ts
@@ -29,7 +29,7 @@ export default declare((api, options: Options) => {
   // Element -> Target scope
   const HOISTED = new WeakMap();
 
-  function declares(node: t.Identifier | t.JSXIdentifier, scope) {
+  function declares(node: t.Identifier | t.JSXIdentifier, scope: Scope) {
     if (
       t.isJSXIdentifier(node, { name: "this" }) ||
       t.isJSXIdentifier(node, { name: "arguments" }) ||
@@ -43,11 +43,11 @@ export default declare((api, options: Options) => {
     return scope.hasOwnBinding(node.name);
   }
 
-  function isHoistingScope({ path }) {
+  function isHoistingScope({ path }: Scope) {
     return path.isFunctionParent() || path.isLoop() || path.isProgram();
   }
 
-  function getHoistingScope(scope) {
+  function getHoistingScope(scope: Scope) {
     while (!isHoistingScope(scope)) scope = scope.parent;
     return scope;
   }
diff --git a/packages/babel-plugin-transform-react-display-name/src/index.ts b/packages/babel-plugin-transform-react-display-name/src/index.ts
index f19c4dd0555f..91d9c85f5a27 100644
--- a/packages/babel-plugin-transform-react-display-name/src/index.ts
+++ b/packages/babel-plugin-transform-react-display-name/src/index.ts
@@ -2,17 +2,24 @@ import { declare } from "@babel/helper-plugin-utils";
 import path from "path";
 import { types as t } from "@babel/core";
 
+type ReactCreateClassCall = t.CallExpression & {
+  arguments: [t.ObjectExpression];
+};
+
 export default declare(api => {
   api.assertVersion(7);
 
-  function addDisplayName(id, call) {
+  function addDisplayName(id: string, call: ReactCreateClassCall) {
     const props = call.arguments[0].properties;
     let safe = true;
 
     for (let i = 0; i < props.length; i++) {
       const prop = props[i];
+      if (t.isSpreadElement(prop)) {
+        continue;
+      }
       const key = t.toComputedKey(prop);
-      if (t.isLiteral(key, { value: "displayName" })) {
+      if (t.isStringLiteral(key, { value: "displayName" })) {
         safe = false;
         break;
       }
@@ -27,9 +34,10 @@ export default declare(api => {
 
   const isCreateClassCallExpression =
     t.buildMatchMemberExpression("React.createClass");
-  const isCreateClassAddon = callee => callee.name === "createReactClass";
+  const isCreateClassAddon = (callee: t.CallExpression["callee"]) =>
+    t.isIdentifier(callee, { name: "createReactClass" });
 
-  function isCreateClass(node) {
+  function isCreateClass(node?: t.Node): node is ReactCreateClassCall {
     if (!node || !t.isCallExpression(node)) return false;
 
     // not createReactClass nor React.createClass call member object
@@ -74,7 +82,7 @@ export default declare(api => {
         const { node } = path;
         if (!isCreateClass(node)) return;
 
-        let id;
+        let id: t.LVal | t.Expression | t.PrivateName | null;
 
         // crawl up the ancestry looking for possible candidates for displayName inference
         path.find(function (path) {
diff --git a/packages/babel-plugin-transform-react-inline-elements/src/index.ts b/packages/babel-plugin-transform-react-inline-elements/src/index.ts
index 46199b940b2b..119971a4f392 100644
--- a/packages/babel-plugin-transform-react-inline-elements/src/index.ts
+++ b/packages/babel-plugin-transform-react-inline-elements/src/index.ts
@@ -5,7 +5,7 @@ import { types as t } from "@babel/core";
 export default declare(api => {
   api.assertVersion(7);
 
-  function hasRefOrSpread(attrs) {
+  function hasRefOrSpread(attrs: t.JSXOpeningElement["attributes"]) {
     for (let i = 0; i < attrs.length; i++) {
       const attr = attrs[i];
       if (t.isJSXSpreadAttribute(attr)) return true;
@@ -14,7 +14,7 @@ export default declare(api => {
     return false;
   }
 
-  function isJSXAttributeOfName(attr, name) {
+  function isJSXAttributeOfName(attr: t.JSXAttribute, name: string) {
     return (
       t.isJSXAttribute(attr) && t.isJSXIdentifier(attr.name, { name: name })
     );
@@ -23,9 +23,8 @@ export default declare(api => {
   const visitor = helper({
     filter(node) {
       return (
-        // Regular JSX nodes have an `openingElement`. JSX fragments, however, don't have an
-        // `openingElement` which causes `node.openingElement.attributes` to throw.
-        node.openingElement && !hasRefOrSpread(node.openingElement.attributes)
+        node.type === "JSXElement" &&
+        !hasRefOrSpread(node.openingElement.attributes)
       );
     },
     pre(state) {
diff --git a/packages/babel-plugin-transform-react-jsx-compat/src/index.ts b/packages/babel-plugin-transform-react-jsx-compat/src/index.ts
index 294607ba79ec..510f20480628 100644
--- a/packages/babel-plugin-transform-react-jsx-compat/src/index.ts
+++ b/packages/babel-plugin-transform-react-jsx-compat/src/index.ts
@@ -8,7 +8,7 @@ export default declare(api => {
   return {
     name: "transform-react-jsx-compat",
 
-    manipulateOptions(opts, parserOpts) {
+    manipulateOptions(_, parserOpts) {
       parserOpts.plugins.push("jsx");
     },
 
diff --git a/packages/babel-plugin-transform-react-jsx-source/src/index.ts b/packages/babel-plugin-transform-react-jsx-source/src/index.ts
index 0f5bee8a3bf9..08602e94a1ee 100644
--- a/packages/babel-plugin-transform-react-jsx-source/src/index.ts
+++ b/packages/babel-plugin-transform-react-jsx-source/src/index.ts
@@ -13,15 +13,23 @@
  * <sometag __source={{fileName: __jsxFileName, lineNumber: 10, columnNumber: 1}}/>
  */
 import { declare } from "@babel/helper-plugin-utils";
-import { types as t } from "@babel/core";
+import { type PluginPass, types as t } from "@babel/core";
+import type { Visitor } from "@babel/traverse";
 
 const TRACE_ID = "__source";
 const FILE_NAME_VAR = "_jsxFileName";
 
-export default declare(api => {
+type State = {
+  fileNameIdentifier: t.Identifier;
+};
+export default declare<State>(api => {
   api.assertVersion(7);
 
-  function makeTrace(fileNameIdentifier, lineNumber, column0Based) {
+  function makeTrace(
+    fileNameIdentifier: t.Identifier,
+    lineNumber: number,
+    column0Based: number,
+  ) {
     const fileLineLiteral =
       lineNumber != null ? t.numericLiteral(lineNumber) : t.nullLiteral();
     const fileColumnLiteral =
@@ -47,18 +55,21 @@ export default declare(api => {
     ]);
   }
 
-  const visitor = {
+  const visitor: Visitor<State & PluginPass> = {
     JSXOpeningElement(path, state) {
       const id = t.jsxIdentifier(TRACE_ID);
-      const location = path.container.openingElement.loc;
+      const location = (path.container as t.JSXElement).openingElement.loc;
       if (!location) {
         // the element was generated and doesn't have location information
         return;
       }
 
-      const attributes = path.container.openingElement.attributes;
+      const attributes = (path.container as t.JSXElement).openingElement
+        .attributes;
       for (let i = 0; i < attributes.length; i++) {
-        const name = attributes[i].name;
+        // @ts-expect-error .name is not defined in JSXSpreadElement
+        const name = attributes[i].name as t.JSXAttribute["name"] | void;
+        // @ts-expect-error TS can not narrow down optional chain
         if (name?.name === TRACE_ID) {
           // The __source attribute already exists
           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 2fb18e6ddb9c..3e3a93963030 100644
--- a/packages/babel-plugin-transform-react-jsx/src/create-plugin.ts
+++ b/packages/babel-plugin-transform-react-jsx/src/create-plugin.ts
@@ -50,8 +50,14 @@ export interface Options {
   useBuiltIns: boolean;
   useSpread?: boolean;
 }
-export default function createPlugin({ name, development }) {
-  return declare((api, options: Options) => {
+export default function createPlugin({
+  name,
+  development,
+}: {
+  name: string;
+  development: boolean;
+}) {
+  return declare((_, options: Options) => {
     const {
       pure: PURE_ANNOTATION,
 
@@ -369,7 +375,10 @@ You can set \`throwIfNamespace: false\` to bypass this warning.`,
       return false;
     }
 
-    function convertJSXIdentifier(node, parent) {
+    function convertJSXIdentifier(
+      node: t.JSXIdentifier | t.JSXMemberExpression | t.JSXNamespacedName,
+      parent: t.JSXOpeningElement | t.JSXMemberExpression,
+    ): t.ThisExpression | t.StringLiteral | t.MemberExpression | t.Identifier {
       if (t.isJSXIdentifier(node)) {
         if (node.name === "this" && t.isReferenced(node, parent)) {
           return t.thisExpression();
@@ -392,10 +401,13 @@ You can set \`throwIfNamespace: false\` to bypass this warning.`,
         return t.stringLiteral(`${node.namespace.name}:${node.name.name}`);
       }
 
+      // @ts-expect-error
       return node;
     }
 
-    function convertAttributeValue(node) {
+    function convertAttributeValue(
+      node: t.JSXAttribute["value"] | t.BooleanLiteral,
+    ) {
       if (t.isJSXExpressionContainer(node)) {
         return node.expression;
       } else {
@@ -486,7 +498,7 @@ You can set \`throwIfNamespace: false\` to bypass this warning.`,
     // Development: React.jsxDEV(type, arguments, key, isStaticChildren, source, self)
     function buildJSXElementCall(path: NodePath<JSXElement>, file: PluginPass) {
       const openingPath = path.get("openingElement");
-      const args = [getTag(openingPath)];
+      const args: t.Expression[] = [getTag(openingPath)];
 
       const attribsArray = [];
       const extracted = Object.create(null);
@@ -640,6 +652,7 @@ You can set \`throwIfNamespace: false\` to bypass this warning.`,
           path,
           openingPath.get("attributes"),
         ),
+        // @ts-expect-error JSXSpreadChild has been transformed in convertAttributeValue
         ...t.react.buildChildren(path.node),
       ]);
     }
@@ -650,11 +663,10 @@ You can set \`throwIfNamespace: false\` to bypass this warning.`,
         openingPath.node,
       );
 
-      let tagName;
+      let tagName: string;
       if (t.isIdentifier(tagExpr)) {
         tagName = tagExpr.name;
-      } else if (t.isLiteral(tagExpr)) {
-        // @ts-expect-error todo(flow->ts) value in missing for NullLiteral
+      } else if (t.isStringLiteral(tagExpr)) {
         tagName = tagExpr.value;
       }
 
@@ -723,7 +735,7 @@ You can set \`throwIfNamespace: false\` to bypass this warning.`,
         }
       }
 
-      const props = [];
+      const props: ObjectExpression["properties"] = [];
       const found = Object.create(null);
 
       for (const attr of attribs) {
diff --git a/packages/babel-plugin-transform-runtime/src/get-runtime-path/browser.ts b/packages/babel-plugin-transform-runtime/src/get-runtime-path/browser.ts
index 94af79f4ce4d..53cc0f75469c 100644
--- a/packages/babel-plugin-transform-runtime/src/get-runtime-path/browser.ts
+++ b/packages/babel-plugin-transform-runtime/src/get-runtime-path/browser.ts
@@ -1,4 +1,8 @@
-export default function (moduleName, dirname, absoluteRuntime) {
+export default function (
+  moduleName: string,
+  dirname: string,
+  absoluteRuntime: string | boolean,
+) {
   if (absoluteRuntime === false) return moduleName;
 
   resolveFSPath();
diff --git a/packages/babel-plugin-transform-runtime/src/get-runtime-path/index.ts b/packages/babel-plugin-transform-runtime/src/get-runtime-path/index.ts
index 37fdc83a6827..ac92873a8e05 100644
--- a/packages/babel-plugin-transform-runtime/src/get-runtime-path/index.ts
+++ b/packages/babel-plugin-transform-runtime/src/get-runtime-path/index.ts
@@ -3,7 +3,11 @@ import path from "path";
 import { createRequire } from "module";
 const require = createRequire(import.meta.url);
 
-export default function (moduleName, dirname, absoluteRuntime) {
+export default function (
+  moduleName: string,
+  dirname: string,
+  absoluteRuntime: string | boolean,
+) {
   if (absoluteRuntime === false) return moduleName;
 
   return resolveAbsoluteRuntime(
@@ -33,6 +37,6 @@ function resolveAbsoluteRuntime(moduleName: string, dirname: string) {
   }
 }
 
-export function resolveFSPath(path) {
+export function resolveFSPath(path: string) {
   return require.resolve(path).replace(/\\/g, "/");
 }
diff --git a/packages/babel-plugin-transform-runtime/src/helpers.ts b/packages/babel-plugin-transform-runtime/src/helpers.ts
index ad77e524f9ae..bea33ed07af0 100644
--- a/packages/babel-plugin-transform-runtime/src/helpers.ts
+++ b/packages/babel-plugin-transform-runtime/src/helpers.ts
@@ -1,6 +1,9 @@
 import semver from "semver";
 
-export function hasMinVersion(minVersion, runtimeVersion) {
+export function hasMinVersion(
+  minVersion: string,
+  runtimeVersion: string | void,
+) {
   // If the range is unavailable, we're running the script during Babel's
   // build process, and we want to assume that all versions are satisfied so
   // that the built output will include all definitions.
diff --git a/packages/babel-plugin-transform-runtime/src/index.ts b/packages/babel-plugin-transform-runtime/src/index.ts
index b734e4b6e3fc..b63c58813828 100644
--- a/packages/babel-plugin-transform-runtime/src/index.ts
+++ b/packages/babel-plugin-transform-runtime/src/index.ts
@@ -4,6 +4,7 @@ import { types as t } from "@babel/core";
 
 import { hasMinVersion } from "./helpers";
 import getRuntimePath, { resolveFSPath } from "./get-runtime-path";
+import type { PluginAPI, PluginObject, CallerMetadata } from "@babel/core";
 
 import _pluginCorejs2 from "babel-plugin-polyfill-corejs2";
 import _pluginCorejs3 from "babel-plugin-polyfill-corejs3";
@@ -17,7 +18,8 @@ const pluginRegenerator = (_pluginRegenerator.default ||
 
 const pluginsCompat = "#__secret_key__@babel/runtime__compatibility";
 
-function supportsStaticESM(caller) {
+function supportsStaticESM(caller: CallerMetadata | undefined) {
+  // @ts-ignore TS does not narrow down optional chaining
   return !!caller?.supportsStaticESM;
 }
 
@@ -30,6 +32,35 @@ export interface Options {
   version?: string;
 }
 
+interface CoreJS2PluginOptions {
+  absoluteImports: string | false;
+  method: "usage-pure";
+  [pluginsCompat]: {
+    runtimeVersion: string;
+    useBabelRuntime: string | false;
+    ext: string;
+  };
+}
+
+interface RegeneratorPluginOptions {
+  absoluteImports: string | false;
+  method: "usage-pure";
+  [pluginsCompat]: {
+    useBabelRuntime: string | false;
+  };
+}
+
+interface CoreJS3PluginOptions {
+  absoluteImports: string | false;
+  method: "usage-pure";
+  proposals: boolean;
+  version: number;
+  [pluginsCompat]: {
+    useBabelRuntime: string | false;
+    ext: string;
+  };
+}
+
 export default declare((api, options: Options, dirname) => {
   api.assertVersion(7);
 
@@ -106,11 +137,12 @@ export default declare((api, options: Options, dirname) => {
     var supportsCJSDefault = hasMinVersion(DUAL_MODE_RUNTIME, runtimeVersion);
   }
 
-  function has(obj, key) {
+  function has(obj: {}, key: string) {
     return Object.prototype.hasOwnProperty.call(obj, key);
   }
 
   if (has(options, "useBuiltIns")) {
+    // @ts-expect-error deprecated options
     if (options["useBuiltIns"]) {
       throw new Error(
         "The 'useBuiltIns' option has been removed. The @babel/runtime " +
@@ -125,6 +157,7 @@ export default declare((api, options: Options, dirname) => {
   }
 
   if (has(options, "polyfill")) {
+    // @ts-expect-error deprecated options
     if (options["polyfill"] === false) {
       throw new Error(
         "The 'polyfill' option has been removed. The @babel/runtime " +
@@ -163,8 +196,20 @@ export default declare((api, options: Options, dirname) => {
 
   const modulePath = getRuntimePath(moduleName, dirname, absoluteRuntime);
 
-  function createCorejsPlgin(plugin, options, regeneratorPlugin) {
-    return (api, _, filename) => {
+  function createCorejsPlgin<Options extends {}>(
+    plugin: (
+      api: PluginAPI,
+      options: Options,
+      filename: string,
+    ) => PluginObject,
+    options: Options,
+    regeneratorPlugin: (
+      api: PluginAPI,
+      options: RegeneratorPluginOptions,
+      filename: string,
+    ) => PluginObject,
+  ): (api: PluginAPI, options: {}, filename: string) => PluginObject {
+    return (api: PluginAPI, _: {}, filename: string) => {
       return {
         ...plugin(api, options, filename),
         inherits: regeneratorPlugin,
@@ -173,7 +218,13 @@ export default declare((api, options: Options, dirname) => {
   }
 
   // TODO: Remove this in Babel 8
-  function createRegeneratorPlugin(options) {
+  function createRegeneratorPlugin(
+    options: RegeneratorPluginOptions,
+  ): (
+    api: PluginAPI,
+    options: RegeneratorPluginOptions,
+    filename: string,
+  ) => PluginObject {
     if (!useRuntimeRegenerator) return undefined;
     return (api, _, filename) => {
       return pluginRegenerator(api, options, filename);
@@ -184,7 +235,7 @@ export default declare((api, options: Options, dirname) => {
     name: "transform-runtime",
 
     inherits: injectCoreJS2
-      ? createCorejsPlgin(
+      ? createCorejsPlgin<CoreJS2PluginOptions>(
           pluginCorejs2,
           {
             method: "usage-pure",
@@ -202,7 +253,7 @@ export default declare((api, options: Options, dirname) => {
           }),
         )
       : injectCoreJS3
-      ? createCorejsPlgin(
+      ? createCorejsPlgin<CoreJS3PluginOptions>(
           pluginCorejs3,
           {
             method: "usage-pure",
@@ -226,7 +277,7 @@ export default declare((api, options: Options, dirname) => {
     pre(file) {
       if (!useRuntimeHelpers) return;
 
-      file.set("helperGenerator", name => {
+      file.set("helperGenerator", (name: string) => {
         // If the helper didn't exist yet at the version given, we bail
         // out and let Babel either insert it directly, or throw an error
         // so that plugins can handle that case properly.
@@ -271,9 +322,9 @@ export default declare((api, options: Options, dirname) => {
       const cache = new Map();
 
       function addDefaultImport(
-        source,
-        nameHint,
-        blockHoist,
+        source: string,
+        nameHint: string,
+        blockHoist: number,
         isHelper = false,
       ) {
         // If something on the page adds a helper when the file is an ES6
diff --git a/packages/babel-plugin-transform-typescript/src/enum.ts b/packages/babel-plugin-transform-typescript/src/enum.ts
index 79368a06656a..9a3234286f69 100644
--- a/packages/babel-plugin-transform-typescript/src/enum.ts
+++ b/packages/babel-plugin-transform-typescript/src/enum.ts
@@ -39,7 +39,7 @@ export default function transpileEnum(
       throw new Error(`Unexpected enum parent '${path.parent.type}`);
   }
 
-  function seen(parentPath: NodePath<t.Node>) {
+  function seen(parentPath: NodePath<t.Node>): boolean {
     if (parentPath.isExportDeclaration()) {
       return seen(parentPath.parentPath);
     }
@@ -193,12 +193,12 @@ export function translateEnumValues(
 
 // Based on the TypeScript repository's `evalConstant` in `checker.ts`.
 function evaluate(
-  expr,
+  expr: t.Node,
   seen: PreviousEnumMembers,
 ): number | string | typeof undefined {
   return evalConstant(expr);
 
-  function evalConstant(expr): number | typeof undefined {
+  function evalConstant(expr: t.Node): number | typeof undefined {
     switch (expr.type) {
       case "StringLiteral":
         return expr.value;
@@ -225,7 +225,7 @@ function evaluate(
   function evalUnaryExpression({
     argument,
     operator,
-  }): number | typeof undefined {
+  }: t.UnaryExpression): number | typeof undefined {
     const value = evalConstant(argument);
     if (value === undefined) {
       return undefined;
@@ -243,7 +243,7 @@ function evaluate(
     }
   }
 
-  function evalBinaryExpression(expr): number | typeof undefined {
+  function evalBinaryExpression(expr: t.BinaryExpression): number | undefined {
     const left = evalConstant(expr.left);
     if (left === undefined) {
       return undefined;
diff --git a/packages/babel-plugin-transform-typescript/src/index.ts b/packages/babel-plugin-transform-typescript/src/index.ts
index 0468c6e04d6b..2ab07a6dd016 100644
--- a/packages/babel-plugin-transform-typescript/src/index.ts
+++ b/packages/babel-plugin-transform-typescript/src/index.ts
@@ -2,7 +2,7 @@ import { declare } from "@babel/helper-plugin-utils";
 import syntaxTypeScript from "@babel/plugin-syntax-typescript";
 import { types as t, template } from "@babel/core";
 import { injectInitialization } from "@babel/helper-create-class-features-plugin";
-import type { NodePath } from "@babel/traverse";
+import type { Binding, NodePath } from "@babel/traverse";
 import type { Options as SyntaxOptions } from "@babel/plugin-syntax-typescript";
 
 import transpileConstEnum from "./const-enum";
@@ -149,7 +149,7 @@ export default declare((api, opts: Options) => {
       if (node.declare) node.declare = null;
       if (node.override) node.override = null;
     },
-    method({ node }) {
+    method({ node }: NodePath<t.ClassMethod | t.ClassPrivateMethod>) {
       if (node.accessibility) node.accessibility = null;
       if (node.abstract) node.abstract = null;
       if (node.optional) node.optional = null;
@@ -157,7 +157,7 @@ export default declare((api, opts: Options) => {
 
       // Rest handled by Function visitor
     },
-    constructor(path, classPath) {
+    constructor(path: NodePath<t.ClassMethod>, classPath: NodePath<t.Class>) {
       if (path.node.accessibility) path.node.accessibility = null;
       // Collects parameter properties so that we can add an assignment
       // for each of them in the constructor body
@@ -487,7 +487,11 @@ export default declare((api, opts: Options) => {
         path.get("body.body").forEach(child => {
           if (child.isClassMethod() || child.isClassPrivateMethod()) {
             if (child.node.kind === "constructor") {
-              classMemberVisitors.constructor(child, path);
+              classMemberVisitors.constructor(
+                // @ts-expect-error A constructor must not be a private method
+                child,
+                path,
+              );
             } else {
               classMemberVisitors.method(child);
             }
@@ -512,7 +516,7 @@ export default declare((api, opts: Options) => {
       },
 
       TSModuleDeclaration(path) {
-        transpileNamespace(path, t, allowNamespaces);
+        transpileNamespace(path, allowNamespaces);
       },
 
       TSInterfaceDeclaration(path) {
@@ -622,7 +626,9 @@ export default declare((api, opts: Options) => {
     return node;
   }
 
-  function visitPattern({ node }) {
+  function visitPattern({
+    node,
+  }: NodePath<t.Identifier | t.Pattern | t.RestElement>) {
     if (node.typeAnnotation) node.typeAnnotation = null;
     if (t.isIdentifier(node) && node.optional) node.optional = null;
     // 'access' and 'readonly' are only for parameter properties, so constructor visitor will handle them.
@@ -633,6 +639,11 @@ export default declare((api, opts: Options) => {
     programPath,
     pragmaImportName,
     pragmaFragImportName,
+  }: {
+    binding: Binding;
+    programPath: NodePath<t.Program>;
+    pragmaImportName: string;
+    pragmaFragImportName: string;
   }) {
     for (const path of binding.referencePaths) {
       if (!isInType(path)) {
diff --git a/packages/babel-plugin-transform-typescript/src/namespace.ts b/packages/babel-plugin-transform-typescript/src/namespace.ts
index 186da7c3c77c..74532eca9412 100644
--- a/packages/babel-plugin-transform-typescript/src/namespace.ts
+++ b/packages/babel-plugin-transform-typescript/src/namespace.ts
@@ -1,29 +1,33 @@
 import { template, types as t } from "@babel/core";
 import type { NodePath } from "@babel/traverse";
 
-export default function transpileNamespace(path, t, allowNamespaces) {
+export default function transpileNamespace(
+  path: NodePath<t.TSModuleDeclaration>,
+  allowNamespaces: boolean,
+) {
   if (path.node.declare || path.node.id.type === "StringLiteral") {
     path.remove();
     return;
   }
 
   if (!allowNamespaces) {
-    throw path.hub.file.buildCodeFrameError(
-      path.node.id,
-      "Namespace not marked type-only declare." +
-        " Non-declarative namespaces are only supported experimentally in Babel." +
-        " To enable and review caveats see:" +
-        " https://babeljs.io/docs/en/babel-plugin-transform-typescript",
-    );
+    throw path
+      .get("id")
+      .buildCodeFrameError(
+        "Namespace not marked type-only declare." +
+          " Non-declarative namespaces are only supported experimentally in Babel." +
+          " To enable and review caveats see:" +
+          " https://babeljs.io/docs/en/babel-plugin-transform-typescript",
+      );
   }
 
   const name = path.node.id.name;
-  const value = handleNested(path, t, t.cloneDeep(path.node));
+  const value = handleNested(path, t.cloneNode(path.node, true));
   const bound = path.scope.hasOwnBinding(name);
   if (path.parent.type === "ExportNamedDeclaration") {
     if (!bound) {
       path.parentPath.insertAfter(value);
-      path.replaceWith(getDeclaration(t, name));
+      path.replaceWith(getDeclaration(name));
       path.scope.registerDeclaration(path.parentPath);
     } else {
       path.parentPath.replaceWith(value);
@@ -32,18 +36,18 @@ export default function transpileNamespace(path, t, allowNamespaces) {
     path.replaceWith(value);
   } else {
     path.scope.registerDeclaration(
-      path.replaceWithMultiple([getDeclaration(t, name), value])[0],
+      path.replaceWithMultiple([getDeclaration(name), value])[0],
     );
   }
 }
 
-function getDeclaration(t, name) {
+function getDeclaration(name: string) {
   return t.variableDeclaration("let", [
     t.variableDeclarator(t.identifier(name)),
   ]);
 }
 
-function getMemberExpression(t, name, itemName) {
+function getMemberExpression(name: string, itemName: string) {
   return t.memberExpression(t.identifier(name), t.identifier(itemName));
 }
 
@@ -79,7 +83,7 @@ function handleVariableDeclaration(
     for (const declarator of declarations) {
       declarator.init = t.assignmentExpression(
         "=",
-        getMemberExpression(t, name, declarator.id.name),
+        getMemberExpression(name, declarator.id.name),
         declarator.init,
       );
     }
@@ -95,7 +99,7 @@ function handleVariableDeclaration(
     assignments.push(
       t.assignmentExpression(
         "=",
-        getMemberExpression(t, name, idName),
+        getMemberExpression(name, idName),
         t.cloneNode(bindingIdentifiers[idName]),
       ),
     );
@@ -113,9 +117,8 @@ function buildNestedAmbiendModuleError(path: NodePath, node: t.Node) {
 
 function handleNested(
   path: NodePath,
-  t: typeof import("@babel/types"),
   node: t.TSModuleDeclaration,
-  parentExport?,
+  parentExport?: t.Expression,
 ) {
   const names = new Set();
   const realName = node.id;
@@ -142,7 +145,7 @@ function handleNested(
           throw buildNestedAmbiendModuleError(path, subNode);
         }
 
-        const transformed = handleNested(path, t, subNode);
+        const transformed = handleNested(path, subNode);
         const moduleName = subNode.id.name;
         if (names.has(moduleName)) {
           namespaceTopLevel[i] = transformed;
@@ -151,7 +154,7 @@ function handleNested(
           namespaceTopLevel.splice(
             i++,
             1,
-            getDeclaration(t, moduleName),
+            getDeclaration(moduleName),
             transformed,
           );
         }
@@ -191,7 +194,7 @@ function handleNested(
           t.expressionStatement(
             t.assignmentExpression(
               "=",
-              getMemberExpression(t, name, itemName),
+              getMemberExpression(name, itemName),
               t.identifier(itemName),
             ),
           ),
@@ -215,7 +218,6 @@ function handleNested(
 
         const transformed = handleNested(
           path,
-          t,
           subNode.declaration,
           t.identifier(name),
         );
@@ -227,7 +229,7 @@ function handleNested(
           namespaceTopLevel.splice(
             i++,
             1,
-            getDeclaration(t, moduleName),
+            getDeclaration(moduleName),
             transformed,
           );
         }
diff --git a/packages/babel-plugin-transform-unicode-escapes/src/index.ts b/packages/babel-plugin-transform-unicode-escapes/src/index.ts
index f21e9cfdaf5c..da962b899f38 100644
--- a/packages/babel-plugin-transform-unicode-escapes/src/index.ts
+++ b/packages/babel-plugin-transform-unicode-escapes/src/index.ts
@@ -1,5 +1,6 @@
 import { declare } from "@babel/helper-plugin-utils";
 import { types as t } from "@babel/core";
+import type { NodePath } from "@babel/traverse";
 
 export default declare(api => {
   api.assertVersion(7);
@@ -7,7 +8,7 @@ export default declare(api => {
   const surrogate = /[\ud800-\udfff]/g;
   const unicodeEscape = /(\\+)u\{([0-9a-fA-F]+)\}/g;
 
-  function escape(code) {
+  function escape(code: number) {
     let str = code.toString(16);
     // Sigh, node 6 doesn't have padStart
     // TODO: Remove in Babel 8, when we drop node 6.
@@ -15,7 +16,7 @@ export default declare(api => {
     return "\\u" + str;
   }
 
-  function replacer(match, backslashes, code) {
+  function replacer(match: string, backslashes: string[], code: string) {
     if (backslashes.length % 2 === 0) {
       return match;
     }
@@ -26,11 +27,11 @@ export default declare(api => {
     return char.length === 1 ? escaped : escaped + escape(char.charCodeAt(1));
   }
 
-  function replaceUnicodeEscapes(str) {
+  function replaceUnicodeEscapes(str: string) {
     return str.replace(unicodeEscape, replacer);
   }
 
-  function getUnicodeEscape(str) {
+  function getUnicodeEscape(str: string) {
     let match;
     while ((match = unicodeEscape.exec(str))) {
       if (match[1].length % 2 === 0) continue;
@@ -88,11 +89,13 @@ export default declare(api => {
         );
       },
 
-      "StringLiteral|DirectiveLiteral"(path) {
+      "StringLiteral|DirectiveLiteral"(
+        path: NodePath<t.StringLiteral | t.DirectiveLiteral>,
+      ) {
         const { node } = path;
         const { extra } = node;
 
-        if (extra?.raw) extra.raw = replaceUnicodeEscapes(extra.raw);
+        if (extra?.raw) extra.raw = replaceUnicodeEscapes(extra.raw as string);
       },
 
       TemplateElement(path) {
diff --git a/packages/babel-preset-env/data/shipped-proposals.js b/packages/babel-preset-env/data/shipped-proposals.js
index ef9fe775dfd8..d583f9a3c8b8 100644
--- a/packages/babel-preset-env/data/shipped-proposals.js
+++ b/packages/babel-preset-env/data/shipped-proposals.js
@@ -1,36 +1,2 @@
-/* eslint sort-keys: "error" */
-// These mappings represent the transform plugins that have been
-// shipped by browsers, and are enabled by the `shippedProposals` option.
-
-const proposalPlugins = new Set();
-
-// proposal syntax plugins enabled by the `shippedProposals` option.
-// Unlike proposalPlugins above, they are independent of compiler targets.
-const proposalSyntaxPlugins = [
-  "syntax-import-assertions"
-]
-
-// use intermediary object to enforce alphabetical key order
-const pluginSyntaxObject = {
-  "proposal-async-generator-functions": "syntax-async-generators",
-  "proposal-class-properties": "syntax-class-properties",
-  "proposal-class-static-block": "syntax-class-static-block",
-  "proposal-json-strings": "syntax-json-strings",
-  "proposal-nullish-coalescing-operator": "syntax-nullish-coalescing-operator",
-  "proposal-numeric-separator": "syntax-numeric-separator",
-  "proposal-object-rest-spread": "syntax-object-rest-spread",
-  "proposal-optional-catch-binding": "syntax-optional-catch-binding",
-  "proposal-optional-chaining": "syntax-optional-chaining",
-  // note: we don't have syntax-private-methods
-  "proposal-private-methods": "syntax-class-properties",
-  "proposal-private-property-in-object": "syntax-private-property-in-object",
-  "proposal-unicode-property-regex": null,
-};
-
-const pluginSyntaxEntries = Object.keys(pluginSyntaxObject).map(function (key) {
-  return [key, pluginSyntaxObject[key]];
-});
-
-const pluginSyntaxMap = new Map(pluginSyntaxEntries);
-
+const { pluginSyntaxMap, proposalPlugins, proposalSyntaxPlugins } = require("../lib/shipped-proposals");
 module.exports = { pluginSyntaxMap, proposalPlugins, proposalSyntaxPlugins };
diff --git a/packages/babel-preset-env/src/debug.ts b/packages/babel-preset-env/src/debug.ts
index 7299f62fc228..97db94e2c123 100644
--- a/packages/babel-preset-env/src/debug.ts
+++ b/packages/babel-preset-env/src/debug.ts
@@ -24,6 +24,7 @@ export const logPlugin = (
     if (!first) formattedTargets += `,`;
     first = false;
     formattedTargets += ` ${target}`;
+    // @ts-ignore
     if (support[target]) formattedTargets += ` < ${support[target]}`;
   }
   formattedTargets += ` }`;
diff --git a/packages/babel-preset-env/src/filter-items.ts b/packages/babel-preset-env/src/filter-items.ts
index cb5b4c0f6341..692c67bdbead 100644
--- a/packages/babel-preset-env/src/filter-items.ts
+++ b/packages/babel-preset-env/src/filter-items.ts
@@ -6,7 +6,7 @@ const has = Function.call.bind(Object.hasOwnProperty);
 
 export function addProposalSyntaxPlugins(
   items: Set<string>,
-  proposalSyntaxPlugins: string[],
+  proposalSyntaxPlugins: readonly string[],
 ) {
   proposalSyntaxPlugins.forEach(plugin => {
     items.add(plugin);
@@ -25,7 +25,14 @@ export function removeUnsupportedItems(
   babelVersion: string,
 ) {
   items.forEach(item => {
-    if (has(minVersions, item) && semver.lt(babelVersion, minVersions[item])) {
+    if (
+      has(minVersions, item) &&
+      semver.lt(
+        babelVersion,
+        // @ts-ignore we have checked minVersions[item] in has call
+        minVersions[item],
+      )
+    ) {
       items.delete(item);
     }
   });
diff --git a/packages/babel-preset-env/src/index.ts b/packages/babel-preset-env/src/index.ts
index 9eb8bc328981..bfd7ff2c1fae 100644
--- a/packages/babel-preset-env/src/index.ts
+++ b/packages/babel-preset-env/src/index.ts
@@ -12,7 +12,7 @@ import {
   pluginSyntaxMap,
   proposalPlugins,
   proposalSyntaxPlugins,
-} from "../data/shipped-proposals";
+} from "./shipped-proposals";
 import {
   plugins as pluginsList,
   pluginsBugfixes as pluginsBugfixesList,
@@ -22,6 +22,8 @@ import overlappingPlugins from "@babel/compat-data/overlapping-plugins";
 import removeRegeneratorEntryPlugin from "./polyfills/regenerator";
 import legacyBabelPolyfillPlugin from "./polyfills/babel-polyfill";
 
+import type { CallerMetadata } from "@babel/core";
+
 import _pluginCoreJS2 from "babel-plugin-polyfill-corejs2";
 import _pluginCoreJS3 from "babel-plugin-polyfill-corejs3";
 import _pluginRegenerator from "babel-plugin-polyfill-regenerator";
@@ -55,6 +57,7 @@ function filterStageFromList(
 ) {
   return Object.keys(list).reduce((result, item) => {
     if (!stageList.has(item)) {
+      // @ts-ignore
       result[item] = list[item];
     }
 
@@ -87,7 +90,9 @@ function getPluginList(proposals: boolean, bugfixes: boolean) {
 }
 
 const getPlugin = (pluginName: string) => {
-  const plugin = availablePlugins[pluginName]();
+  const plugin =
+    // @ts-ignore plugin name is constructed from available plugin list
+    availablePlugins[pluginName]();
 
   if (!plugin) {
     throw new Error(
@@ -243,10 +248,10 @@ export const getPolyfillPlugins = ({
 };
 
 function getLocalTargets(
-  optionsTargets,
-  ignoreBrowserslistConfig,
-  configPath,
-  browserslistEnv,
+  optionsTargets: Options["targets"],
+  ignoreBrowserslistConfig: boolean,
+  configPath: string,
+  browserslistEnv: string,
 ) {
   if (optionsTargets?.esmodules && optionsTargets.browsers) {
     console.warn(`
@@ -262,19 +267,23 @@ function getLocalTargets(
   });
 }
 
-function supportsStaticESM(caller) {
+function supportsStaticESM(caller: CallerMetadata | undefined) {
+  // @ts-expect-error supportsStaticESM is not defined in CallerMetadata
   return !!caller?.supportsStaticESM;
 }
 
-function supportsDynamicImport(caller) {
+function supportsDynamicImport(caller: CallerMetadata | undefined) {
+  // @ts-expect-error supportsDynamicImport is not defined in CallerMetadata
   return !!caller?.supportsDynamicImport;
 }
 
-function supportsExportNamespaceFrom(caller) {
+function supportsExportNamespaceFrom(caller: CallerMetadata | undefined) {
+  // @ts-expect-error supportsExportNamespaceFrom is not defined in CallerMetadata
   return !!caller?.supportsExportNamespaceFrom;
 }
 
-function supportsTopLevelAwait(caller) {
+function supportsTopLevelAwait(caller: CallerMetadata | undefined) {
+  // @ts-expect-error supportsTopLevelAwait is not defined in CallerMetadata
   return !!caller?.supportsTopLevelAwait;
 }
 
diff --git a/packages/babel-preset-env/src/normalize-options.ts b/packages/babel-preset-env/src/normalize-options.ts
index 4f1e9288e33a..4c550303c7bd 100644
--- a/packages/babel-preset-env/src/normalize-options.ts
+++ b/packages/babel-preset-env/src/normalize-options.ts
@@ -1,5 +1,8 @@
 import semver, { type SemVer } from "semver";
 import corejs2Polyfills from "@babel/compat-data/corejs2-built-ins";
+// @ts-ignore Fixme: TS can not infer types from ../data/core-js-compat.js
+// but we can't import core-js-compat/data.json because JSON imports does
+// not work on Node 14
 import corejs3Polyfills from "../data/core-js-compat";
 import { plugins as pluginsList } from "./plugins-compat-data";
 import moduleTransformations from "./module-transformations";
@@ -112,7 +115,9 @@ export const checkDuplicateIncludeExcludes = (
   );
 };
 
-const normalizeTargets = (targets): Options["targets"] => {
+const normalizeTargets = (
+  targets: string | string[] | Options["targets"],
+): Options["targets"] => {
   // TODO: Allow to use only query or strings as a targets from next breaking change.
   if (typeof targets === "string" || Array.isArray(targets)) {
     return { browsers: targets };
@@ -124,6 +129,7 @@ export const validateModulesOption = (
   modulesOpt: ModuleOption = ModulesOption.auto,
 ) => {
   v.invariant(
+    // @ts-ignore we have provided fallback for undefined keys
     ModulesOption[modulesOpt.toString()] || modulesOpt === ModulesOption.false,
     `The 'modules' option must be one of \n` +
       ` - 'false' to indicate no module processing\n` +
@@ -139,6 +145,7 @@ export const validateUseBuiltInsOption = (
   builtInsOpt: BuiltInsOption = false,
 ) => {
   v.invariant(
+    // @ts-ignore we have provided fallback for undefined keys
     UseBuiltInsOption[builtInsOpt.toString()] ||
       builtInsOpt === UseBuiltInsOption.false,
     `The 'useBuiltIns' option must be either
@@ -260,7 +267,7 @@ export default function normalizeOptions(opts: Options) {
     spec: v.validateBooleanOption(TopLevelOptions.spec, opts.spec, false),
     targets: normalizeTargets(opts.targets),
     useBuiltIns: useBuiltIns,
-    browserslistEnv: v.validateStringOption(
+    browserslistEnv: v.validateStringOption<string>(
       TopLevelOptions.browserslistEnv,
       opts.browserslistEnv,
     ),
diff --git a/packages/babel-preset-env/src/plugins-compat-data.ts b/packages/babel-preset-env/src/plugins-compat-data.ts
index 583395499dd0..2324c6c78919 100644
--- a/packages/babel-preset-env/src/plugins-compat-data.ts
+++ b/packages/babel-preset-env/src/plugins-compat-data.ts
@@ -7,12 +7,14 @@ const bugfixPluginsFiltered = {};
 
 for (const plugin of Object.keys(plugins)) {
   if (Object.hasOwnProperty.call(availablePlugins, plugin)) {
+    // @ts-ignore
     pluginsFiltered[plugin] = plugins[plugin];
   }
 }
 
 for (const plugin of Object.keys(bugfixPlugins)) {
   if (Object.hasOwnProperty.call(availablePlugins, plugin)) {
+    // @ts-ignore
     bugfixPluginsFiltered[plugin] = bugfixPlugins[plugin];
   }
 }
diff --git a/packages/babel-preset-env/src/polyfills/regenerator.ts b/packages/babel-preset-env/src/polyfills/regenerator.ts
index 046dfdcace42..e9b5111dc8b2 100644
--- a/packages/babel-preset-env/src/polyfills/regenerator.ts
+++ b/packages/babel-preset-env/src/polyfills/regenerator.ts
@@ -2,7 +2,7 @@ import { getImportSource, getRequireSource } from "./utils";
 import type { Visitor } from "@babel/traverse";
 import type { PluginObject, PluginPass } from "@babel/core";
 
-function isRegeneratorSource(source) {
+function isRegeneratorSource(source: string) {
   return (
     source === "regenerator-runtime/runtime" ||
     source === "regenerator-runtime/runtime.js"
diff --git a/packages/babel-preset-env/src/shipped-proposals.ts b/packages/babel-preset-env/src/shipped-proposals.ts
new file mode 100644
index 000000000000..fb77edc566e7
--- /dev/null
+++ b/packages/babel-preset-env/src/shipped-proposals.ts
@@ -0,0 +1,41 @@
+// TODO(Babel 8): Remove this file
+/* eslint sort-keys: "error" */
+// These mappings represent the transform plugins that have been
+// shipped by browsers, and are enabled by the `shippedProposals` option.
+
+const proposalPlugins = new Set<string>();
+
+// proposal syntax plugins enabled by the `shippedProposals` option.
+// Unlike proposalPlugins above, they are independent of compiler targets.
+const proposalSyntaxPlugins = ["syntax-import-assertions"] as const;
+
+// use intermediary object to enforce alphabetical key order
+const pluginSyntaxObject = {
+  "proposal-async-generator-functions": "syntax-async-generators",
+  "proposal-class-properties": "syntax-class-properties",
+  "proposal-class-static-block": "syntax-class-static-block",
+  "proposal-json-strings": "syntax-json-strings",
+  "proposal-nullish-coalescing-operator": "syntax-nullish-coalescing-operator",
+  "proposal-numeric-separator": "syntax-numeric-separator",
+  "proposal-object-rest-spread": "syntax-object-rest-spread",
+  "proposal-optional-catch-binding": "syntax-optional-catch-binding",
+  "proposal-optional-chaining": "syntax-optional-chaining",
+  // note: we don't have syntax-private-methods
+  "proposal-private-methods": "syntax-class-properties",
+  "proposal-private-property-in-object": "syntax-private-property-in-object",
+  "proposal-unicode-property-regex": null as null,
+} as const;
+
+const pluginSyntaxEntries = Object.keys(pluginSyntaxObject).map<
+  [string, string | null]
+>(function (key) {
+  return [
+    key,
+    // @ts-expect-error key has been guarded
+    pluginSyntaxObject[key],
+  ];
+});
+
+const pluginSyntaxMap = new Map(pluginSyntaxEntries);
+
+export { proposalPlugins, proposalSyntaxPlugins, pluginSyntaxMap };
diff --git a/packages/babel-preset-typescript/src/index.ts b/packages/babel-preset-typescript/src/index.ts
index e9fb7b515204..5fce63166f9e 100644
--- a/packages/babel-preset-typescript/src/index.ts
+++ b/packages/babel-preset-typescript/src/index.ts
@@ -18,7 +18,7 @@ export default declarePreset((api, opts: Options) => {
   } = normalizeOptions(opts);
 
   const pluginOptions = process.env.BABEL_8_BREAKING
-    ? (isTSX, disallowAmbiguousJSXLike) => ({
+    ? (isTSX: boolean, disallowAmbiguousJSXLike: boolean) => ({
         allowNamespaces,
         disallowAmbiguousJSXLike,
         isTSX,
@@ -27,7 +27,7 @@ export default declarePreset((api, opts: Options) => {
         onlyRemoveTypeImports,
         optimizeConstEnums,
       })
-    : (isTSX, disallowAmbiguousJSXLike) => ({
+    : (isTSX: boolean, disallowAmbiguousJSXLike: boolean) => ({
         allowDeclareFields: opts.allowDeclareFields,
         allowNamespaces,
         disallowAmbiguousJSXLike,
diff --git a/packages/babel-standalone/src/index.ts b/packages/babel-standalone/src/index.ts
index 1b2ae5ee9b17..b56ba463b8aa 100644
--- a/packages/babel-standalone/src/index.ts
+++ b/packages/babel-standalone/src/index.ts
@@ -26,6 +26,7 @@ import presetEnv from "@babel/preset-env";
 import presetFlow from "@babel/preset-flow";
 import presetReact from "@babel/preset-react";
 import presetTypescript from "@babel/preset-typescript";
+import type { InputOptions } from "@babel/core";
 
 import { runScripts } from "./transformScriptTags";
 
@@ -40,7 +41,7 @@ const isArray =
  * Returns undefined if the preset or plugin is not available; passes through
  * name unmodified if it (or the first element of the pair) is not a string.
  */
-function loadBuiltin(builtinTable, name) {
+function loadBuiltin(builtinTable: Record<string, unknown>, name: any) {
   if (isArray(name) && typeof name[0] === "string") {
     if (Object.prototype.hasOwnProperty.call(builtinTable, name[0])) {
       return [builtinTable[name[0]]].concat(name.slice(1));
@@ -56,7 +57,7 @@ function loadBuiltin(builtinTable, name) {
 /**
  * Parses plugin names and presets from the specified options.
  */
-function processOptions(options) {
+function processOptions(options: InputOptions) {
   // Parse preset names
   const presets = (options.presets || []).map(presetName => {
     const preset = loadBuiltin(availablePresets, presetName);
@@ -100,15 +101,19 @@ function processOptions(options) {
   };
 }
 
-export function transform(code: string, options: any) {
+export function transform(code: string, options: InputOptions) {
   return babelTransformSync(code, processOptions(options));
 }
 
-export function transformFromAst(ast: any, code: string, options: any) {
+export function transformFromAst(
+  ast: Parameters<typeof babelTransformFromAstSync>[0],
+  code: string,
+  options: InputOptions,
+) {
   return babelTransformFromAstSync(ast, code, processOptions(options));
 }
-export const availablePlugins = {};
-export const availablePresets = {};
+export const availablePlugins: typeof all = {};
+
 export const buildExternalHelpers = babelBuildExternalHelpers;
 /**
  * Registers a named plugin for use with Babel.
@@ -148,6 +153,7 @@ export function registerPreset(name: string, preset: any | Function): void {
       );
     }
   }
+  // @ts-expect-error mutating available presets
   availablePresets[name] = preset;
 }
 /**
@@ -170,7 +176,7 @@ registerPlugins(all);
 // All the presets we should bundle
 // Want to get rid of this list of allowed presets?
 // Wait! Please read https://github.com/babel/babel/pull/6177 first.
-registerPresets({
+export const availablePresets = {
   env: presetEnv,
   es2015: preset2015,
   es2016: () => {
@@ -197,7 +203,7 @@ registerPresets({
   },
   typescript: presetTypescript,
   flow: presetFlow,
-});
+};
 
 // @ts-ignore VERSION is to be replaced by rollup
 export const version: string = VERSION;
@@ -216,7 +222,9 @@ if (typeof window !== "undefined" && window?.addEventListener) {
  * Transform <script> tags with "text/babel" type.
  * @param {Array} scriptTags specify script tags to transform, transform all in the <head> if not given
  */
-export function transformScriptTags(scriptTags?: Array<any>) {
+export function transformScriptTags(
+  scriptTags?: HTMLCollectionOf<HTMLScriptElement>,
+) {
   runScripts(transform, scriptTags);
 }
 
diff --git a/packages/babel-standalone/src/transformScriptTags.ts b/packages/babel-standalone/src/transformScriptTags.ts
index 3ffc04f2c552..58dcbf469ff9 100644
--- a/packages/babel-standalone/src/transformScriptTags.ts
+++ b/packages/babel-standalone/src/transformScriptTags.ts
@@ -8,13 +8,32 @@
 
 const scriptTypes = ["text/jsx", "text/babel"];
 
-let headEl;
+import { transform } from "./index";
+import type { InputOptions } from "@babel/core";
+
+let headEl: HTMLHeadElement;
 let inlineScriptCount = 0;
 
+type CompilationResult = {
+  async: boolean;
+  type: string;
+  error: boolean;
+  loaded: boolean;
+  content: string | null;
+  executed: boolean;
+  // todo: refine plugins/presets
+  plugins: InputOptions["plugins"];
+  presets: InputOptions["presets"];
+  url: string | null;
+};
+
 /**
  * Actually transform the code.
  */
-function transformCode(transformFn, script) {
+function transformCode(
+  transformFn: typeof transform,
+  script: CompilationResult,
+) {
   let source;
   if (script.url != null) {
     source = script.url;
@@ -33,7 +52,7 @@ function transformCode(transformFn, script) {
  * Builds the Babel options for transforming the specified script, using some
  * sensible default presets and plugins if none were explicitly provided.
  */
-function buildBabelOptions(script, filename) {
+function buildBabelOptions(script: CompilationResult, filename: string) {
   let presets = script.presets;
   if (!presets) {
     if (script.type === "module") {
@@ -62,7 +81,7 @@ function buildBabelOptions(script, filename) {
       "proposal-object-rest-spread",
       "transform-flow-strip-types",
     ],
-    sourceMaps: "inline",
+    sourceMaps: "inline" as const,
     sourceFileName: filename,
   };
 }
@@ -71,7 +90,7 @@ function buildBabelOptions(script, filename) {
  * Appends a script element at the end of the <head> with the content of code,
  * after transforming it.
  */
-function run(transformFn, script) {
+function run(transformFn: typeof transform, script: CompilationResult) {
   const scriptEl = document.createElement("script");
   if (script.type) {
     scriptEl.setAttribute("type", script.type);
@@ -83,7 +102,11 @@ function run(transformFn, script) {
 /**
  * Load script from the provided url and pass the content to the callback.
  */
-function load(url, successCallback, errorCallback) {
+function load(
+  url: string,
+  successCallback: (content: string) => void,
+  errorCallback: () => void,
+) {
   const xhr = new XMLHttpRequest();
 
   // async, however scripts will be executed in the order they are in the
@@ -110,7 +133,10 @@ function load(url, successCallback, errorCallback) {
  * the string is empty, returns an empty array. If the string is not defined,
  * returns null.
  */
-function getPluginsOrPresetsFromScript(script, attributeName) {
+function getPluginsOrPresetsFromScript(
+  script: HTMLScriptElement,
+  attributeName: string,
+) {
   const rawValue = script.getAttribute(attributeName);
   if (rawValue === "") {
     // Empty string means to not load ANY presets or plugins
@@ -129,8 +155,11 @@ function getPluginsOrPresetsFromScript(script, attributeName) {
  * inline script, or by using XHR. Transforms are applied if needed. The scripts
  * are executed in the order they are found on the page.
  */
-function loadScripts(transformFn, scripts) {
-  const result = [];
+function loadScripts(
+  transformFn: typeof transform,
+  scripts: HTMLScriptElement[],
+) {
+  const result: CompilationResult[] = [];
   const count = scripts.length;
 
   function check() {
@@ -196,7 +225,10 @@ function loadScripts(transformFn, scripts) {
  * Run script tags with type="text/jsx".
  * @param {Array} scriptTags specify script tags to run, run all in the <head> if not given
  */
-export function runScripts(transformFn, scripts) {
+export function runScripts(
+  transformFn: typeof transform,
+  scripts?: HTMLCollectionOf<HTMLScriptElement>,
+) {
   headEl = document.getElementsByTagName("head")[0];
   if (!scripts) {
     scripts = document.getElementsByTagName("script");
diff --git a/packages/babel-template/src/builder.ts b/packages/babel-template/src/builder.ts
index 7040f81595e2..e3acc3878da4 100644
--- a/packages/babel-template/src/builder.ts
+++ b/packages/babel-template/src/builder.ts
@@ -13,7 +13,7 @@ export type TemplateBuilder<T> = {
   (tpl: string, opts?: PublicOpts): (replacements?: PublicReplacements) => T;
 
   // Building from a template literal produces an AST builder function by default.
-  (tpl: TemplateStringsArray, ...args: Array<any>): (
+  (tpl: TemplateStringsArray, ...args: Array<unknown>): (
     replacements?: PublicReplacements,
   ) => T;
 
@@ -21,7 +21,7 @@ export type TemplateBuilder<T> = {
   // the need for an intermediate function.
   ast: {
     (tpl: string, opts?: PublicOpts): T;
-    (tpl: TemplateStringsArray, ...args: Array<any>): T;
+    (tpl: TemplateStringsArray, ...args: Array<unknown>): T;
   };
 };
 
@@ -66,7 +66,7 @@ export default function createTemplateBuilder<T>(
       throw new Error(`Unexpected template param ${typeof tpl}`);
     }) as TemplateBuilder<T>,
     {
-      ast: (tpl, ...args) => {
+      ast: (tpl: string | Array<string>, ...args: Array<unknown>) => {
         if (typeof tpl === "string") {
           if (args.length > 1) throw new Error("Unexpected extra params.");
           return stringTemplate(
diff --git a/packages/babel-template/src/literal.ts b/packages/babel-template/src/literal.ts
index c436edcbd8db..c6e79a1fcc8f 100644
--- a/packages/babel-template/src/literal.ts
+++ b/packages/babel-template/src/literal.ts
@@ -46,7 +46,7 @@ function buildLiteralData<T>(
   opts: TemplateOpts,
 ) {
   let names;
-  let nameSet;
+  let nameSet: Set<string>;
   let metadata;
   let prefix = "";
 
diff --git a/packages/babel-template/src/parse.ts b/packages/babel-template/src/parse.ts
index e57d5b87a273..2fd61025ac2f 100644
--- a/packages/babel-template/src/parse.ts
+++ b/packages/babel-template/src/parse.ts
@@ -54,15 +54,15 @@ export default function parseAndBuildMetadata<T>(
 
   formatter.validate(ast);
 
-  const syntactic = {
+  const syntactic: MetadataState["syntactic"] = {
     placeholders: [],
-    placeholderNames: new Set<string>(),
+    placeholderNames: new Set(),
   };
-  const legacy = {
+  const legacy: MetadataState["legacy"] = {
     placeholders: [],
-    placeholderNames: new Set<string>(),
+    placeholderNames: new Set(),
   };
-  const isLegacyRef = { value: undefined };
+  const isLegacyRef: MetadataState["isLegacyRef"] = { value: undefined };
 
   traverse(ast, placeholderVisitorHandler as TraversalHandler<any>, {
     syntactic,
diff --git a/packages/babel-template/src/string.ts b/packages/babel-template/src/string.ts
index 1f8ad4c9f783..10f26fb64ebe 100644
--- a/packages/babel-template/src/string.ts
+++ b/packages/babel-template/src/string.ts
@@ -1,5 +1,6 @@
 import type { Formatter } from "./formatters";
 import type { TemplateOpts } from "./options";
+import type { Metadata } from "./parse";
 import { normalizeReplacements } from "./options";
 import parseAndBuildMetadata from "./parse";
 import populatePlaceholders from "./populate";
@@ -11,7 +12,7 @@ export default function stringTemplate<T>(
 ): (arg?: unknown) => T {
   code = formatter.code(code);
 
-  let metadata;
+  let metadata: Metadata;
 
   return (arg?: unknown) => {
     const replacements = normalizeReplacements(arg);
diff --git a/packages/babel-traverse/src/context.ts b/packages/babel-traverse/src/context.ts
index 4ac5f580d99b..0ad063102cf5 100644
--- a/packages/babel-traverse/src/context.ts
+++ b/packages/babel-traverse/src/context.ts
@@ -1,9 +1,17 @@
 import NodePath from "./path";
 import { VISITOR_KEYS } from "@babel/types";
 import type Scope from "./scope";
-
-export default class TraversalContext {
-  constructor(scope, opts, state, parentPath) {
+import type { TraverseOptions } from ".";
+import type * as t from "@babel/types";
+import type { Visitor } from "./types";
+
+export default class TraversalContext<S = unknown> {
+  constructor(
+    scope: Scope,
+    opts: TraverseOptions,
+    state: S,
+    parentPath: NodePath,
+  ) {
     this.parentPath = parentPath;
     this.scope = scope;
     this.state = state;
@@ -12,8 +20,8 @@ export default class TraversalContext {
 
   declare parentPath: NodePath;
   declare scope: Scope;
-  declare state;
-  declare opts;
+  declare state: S;
+  declare opts: TraverseOptions;
   queue: Array<NodePath> | null = null;
   priorityQueue: Array<NodePath> | null = null;
 
@@ -22,8 +30,8 @@ export default class TraversalContext {
    * visit a node. This will prevent us from constructing a NodePath.
    */
 
-  shouldVisit(node): boolean {
-    const opts = this.opts;
+  shouldVisit(node: t.Node): boolean {
+    const opts = this.opts as Visitor;
     if (opts.enter || opts.exit) return true;
 
     // check if we have a visitor for this node
@@ -35,25 +43,35 @@ export default class TraversalContext {
 
     // we need to traverse into this node so ensure that it has children to traverse into!
     for (const key of keys) {
-      if (node[key]) return true;
+      if (
+        // @ts-ignore key is from visitor keys
+        node[key]
+      ) {
+        return true;
+      }
     }
 
     return false;
   }
 
-  create(node, obj, key, listKey?): NodePath {
+  create(
+    node: t.Node,
+    container: t.Node | t.Node[],
+    key: string | number,
+    listKey?: string,
+  ): NodePath {
     // We don't need to `.setContext()` here, since `.visitQueue()` already
     // calls `.pushContext`.
     return NodePath.get({
       parentPath: this.parentPath,
       parent: node,
-      container: obj,
+      container,
       key: key,
       listKey,
     });
   }
 
-  maybeQueue(path, notPriority?: boolean) {
+  maybeQueue(path: NodePath, notPriority?: boolean) {
     if (this.queue) {
       if (notPriority) {
         this.queue.push(path);
@@ -63,7 +81,7 @@ export default class TraversalContext {
     }
   }
 
-  visitMultiple(container, parent, listKey) {
+  visitMultiple(container: t.Node[], parent: t.Node, listKey: string) {
     // nothing to traverse!
     if (container.length === 0) return false;
 
@@ -80,15 +98,20 @@ export default class TraversalContext {
     return this.visitQueue(queue);
   }
 
-  visitSingle(node, key): boolean {
-    if (this.shouldVisit(node[key])) {
+  visitSingle(node: t.Node, key: string): boolean {
+    if (
+      this.shouldVisit(
+        // @ts-expect-error
+        node[key],
+      )
+    ) {
       return this.visitQueue([this.create(node, node, key)]);
     } else {
       return false;
     }
   }
 
-  visitQueue(queue: Array<NodePath>) {
+  visitQueue(queue: Array<NodePath>): boolean {
     // set queue
     this.queue = queue;
     this.priorityQueue = [];
@@ -142,8 +165,9 @@ export default class TraversalContext {
     return stop;
   }
 
-  visit(node, key) {
-    const nodes = node[key];
+  visit(node: t.Node, key: string) {
+    // @ts-expect-error
+    const nodes = node[key] as t.Node | t.Node[] | null;
     if (!nodes) return false;
 
     if (Array.isArray(nodes)) {
diff --git a/packages/babel-traverse/src/hub.ts b/packages/babel-traverse/src/hub.ts
index 1894d9930add..c3aa8add3bb8 100644
--- a/packages/babel-traverse/src/hub.ts
+++ b/packages/babel-traverse/src/hub.ts
@@ -1,10 +1,11 @@
 import type Scope from "./scope";
+import type { Node } from "@babel/types";
 
 export interface HubInterface {
   getCode(): string | void;
   getScope(): Scope | void;
   addHelper(name: string): any;
-  buildError(node: any, msg: string, Error: new () => Error): Error;
+  buildError(node: Node, msg: string, Error: new () => Error): Error;
 }
 
 export default class Hub implements HubInterface {
@@ -16,7 +17,7 @@ export default class Hub implements HubInterface {
     throw new Error("Helpers are not supported by the default hub.");
   }
 
-  buildError(node, msg, Error = TypeError): Error {
+  buildError(node: Node, msg: string, Error = TypeError): Error {
     return new Error(msg);
   }
 }
diff --git a/packages/babel-traverse/src/index.ts b/packages/babel-traverse/src/index.ts
index 4cfaca7c07fa..d6c242994364 100644
--- a/packages/babel-traverse/src/index.ts
+++ b/packages/babel-traverse/src/index.ts
@@ -1,5 +1,10 @@
 import * as visitors from "./visitors";
-import { VISITOR_KEYS, removeProperties, traverseFast } from "@babel/types";
+import {
+  VISITOR_KEYS,
+  removeProperties,
+  type RemovePropertiesOptions,
+  traverseFast,
+} from "@babel/types";
 import type * as t from "@babel/types";
 import * as cache from "./cache";
 import type NodePath from "./path";
@@ -15,6 +20,11 @@ export type { HubInterface } from "./hub";
 
 export { visitors };
 
+// fixme: The TraverseOptions should have been { scope ... } & Visitor<S>
+// however TS does not support excluding certain string literals from general string
+// type. If we change here to { scope ... } & Visitor<S>, TS will throw
+// noScope: boolean because it matched `noScope` to the [k in string]: VisitNode<> catch-all
+// in Visitor
 export type TraverseOptions<S = t.Node> =
   | {
       scope?: Scope;
@@ -39,9 +49,10 @@ function traverse(
   parentPath?: NodePath,
 ): void;
 
-function traverse(
+function traverse<Options extends TraverseOptions>(
   parent: t.Node,
-  opts: TraverseOptions = {},
+  // @ts-ignore provide {} as default value for Options
+  opts: Options = {},
   scope?: Scope,
   state?: any,
   parentPath?: NodePath,
@@ -62,7 +73,7 @@ function traverse(
     return;
   }
 
-  visitors.explode(opts);
+  visitors.explode(opts as Visitor);
 
   traverseNode(parent, opts, scope, state, parentPath);
 }
@@ -73,7 +84,7 @@ traverse.visitors = visitors;
 traverse.verify = visitors.verify;
 traverse.explode = visitors.explode;
 
-traverse.cheap = function (node, enter) {
+traverse.cheap = function (node: t.Node, enter: (node: t.Node) => void) {
   return traverseFast(node, enter);
 };
 
@@ -83,24 +94,31 @@ traverse.node = function (
   scope?: Scope,
   state?: any,
   path?: NodePath,
-  skipKeys?: string[],
+  skipKeys?: Record<string, boolean>,
 ) {
   traverseNode(node, opts, scope, state, path, skipKeys);
   // traverse.node always returns undefined
 };
 
-traverse.clearNode = function (node: t.Node, opts?) {
+traverse.clearNode = function (node: t.Node, opts?: RemovePropertiesOptions) {
   removeProperties(node, opts);
 
   cache.path.delete(node);
 };
 
-traverse.removeProperties = function (tree, opts?) {
+traverse.removeProperties = function (
+  tree: t.Node,
+  opts?: RemovePropertiesOptions,
+) {
   traverseFast(tree, traverse.clearNode, opts);
   return tree;
 };
 
-function hasDenylistedType(path: NodePath, state) {
+type HasDenylistedTypeState = {
+  has: boolean;
+  type: t.Node["type"];
+};
+function hasDenylistedType(path: NodePath, state: HasDenylistedTypeState) {
   if (path.node.type === state.type) {
     state.has = true;
     path.stop();
@@ -108,8 +126,8 @@ function hasDenylistedType(path: NodePath, state) {
 }
 
 traverse.hasType = function (
-  tree: any,
-  type: any,
+  tree: t.Node,
+  type: t.Node["type"],
   denylistTypes?: Array<string>,
 ): boolean {
   // the node we're searching in is denylisted
@@ -118,7 +136,7 @@ traverse.hasType = function (
   // the type we're looking for is the same as the passed node
   if (tree.type === type) return true;
 
-  const state = {
+  const state: HasDenylistedTypeState = {
     has: false,
     type: type,
   };
diff --git a/packages/babel-traverse/src/path/ancestry.ts b/packages/babel-traverse/src/path/ancestry.ts
index 0381427724f7..742a49d2cf39 100644
--- a/packages/babel-traverse/src/path/ancestry.ts
+++ b/packages/babel-traverse/src/path/ancestry.ts
@@ -133,7 +133,7 @@ export function getEarliestCommonAncestorFrom(
 export function getDeepestCommonAncestorFrom(
   this: NodePath,
   paths: Array<NodePath>,
-  filter?: (deepest: t.Node, i: number, ancestries: NodePath[][]) => NodePath,
+  filter?: (deepest: NodePath, i: number, ancestries: NodePath[][]) => NodePath,
 ): NodePath {
   if (!paths.length) {
     return this;
diff --git a/packages/babel-traverse/src/path/comments.ts b/packages/babel-traverse/src/path/comments.ts
index 6e23a9be724f..8f7384794c43 100644
--- a/packages/babel-traverse/src/path/comments.ts
+++ b/packages/babel-traverse/src/path/comments.ts
@@ -48,7 +48,7 @@ export function addComment(
 export function addComments(
   this: NodePath,
   type: t.CommentTypeShorthand,
-  comments: readonly t.Comment[],
+  comments: t.Comment[],
 ) {
   _addComments(this.node, type, comments);
 }
diff --git a/packages/babel-traverse/src/path/context.ts b/packages/babel-traverse/src/path/context.ts
index f6cba6fe1b4f..de5d4bbc7d35 100644
--- a/packages/babel-traverse/src/path/context.ts
+++ b/packages/babel-traverse/src/path/context.ts
@@ -4,6 +4,7 @@ import { traverseNode } from "../traverse-node";
 import { SHOULD_SKIP, SHOULD_STOP } from "./index";
 import type TraversalContext from "../context";
 import type NodePath from "./index";
+import type * as t from "@babel/types";
 
 export function call(this: NodePath, key: string): boolean {
   const opts = this.opts;
@@ -152,7 +153,10 @@ export function setScope(this: NodePath) {
   if (this.scope) this.scope.init();
 }
 
-export function setContext(this: NodePath, context?: TraversalContext) {
+export function setContext<S = unknown>(
+  this: NodePath,
+  context?: TraversalContext<S>,
+) {
   if (this.skipKeys != null) {
     this.skipKeys = {};
   }
@@ -194,7 +198,13 @@ export function _resyncParent(this: NodePath) {
 export function _resyncKey(this: NodePath) {
   if (!this.container) return;
 
-  if (this.node === this.container[this.key]) return;
+  if (
+    this.node ===
+    // @ts-expect-error this.key should present in this.container
+    this.container[this.key]
+  ) {
+    return;
+  }
 
   // grrr, path key is out of sync. this is likely due to a modification to the AST
   // not done through our path APIs
@@ -207,6 +217,7 @@ export function _resyncKey(this: NodePath) {
     }
   } else {
     for (const key of Object.keys(this.container)) {
+      // @ts-expect-error this.key should present in this.container
       if (this.container[key] === this.node) {
         return this.setKey(key);
       }
@@ -220,7 +231,9 @@ export function _resyncKey(this: NodePath) {
 export function _resyncList(this: NodePath) {
   if (!this.parent || !this.inList) return;
 
-  const newContainer = this.parent[this.listKey];
+  const newContainer =
+    // @ts-expect-error this.listKey should present in this.parent
+    this.parent[this.listKey];
   if (this.container === newContainer) return;
 
   // container is out of sync. this is likely the result of it being reassigned
@@ -231,6 +244,7 @@ export function _resyncRemoved(this: NodePath) {
   if (
     this.key == null ||
     !this.container ||
+    // @ts-expect-error this.key should present in this.container
     this.container[this.key] !== this.node
   ) {
     this._markRemoved();
@@ -251,7 +265,13 @@ export function pushContext(this: NodePath, context: TraversalContext) {
   this.setContext(context);
 }
 
-export function setup(this: NodePath, parentPath, container, listKey, key) {
+export function setup(
+  this: NodePath,
+  parentPath: NodePath | undefined,
+  container: t.Node,
+  listKey: string,
+  key: string | number,
+) {
   this.listKey = listKey;
   this.container = container;
 
@@ -259,9 +279,11 @@ export function setup(this: NodePath, parentPath, container, listKey, key) {
   this.setKey(key);
 }
 
-export function setKey(this: NodePath, key) {
+export function setKey(this: NodePath, key: string | number) {
   this.key = key;
-  this.node = this.container[this.key];
+  this.node =
+    // @ts-expect-error this.key must present in this.container
+    this.container[this.key];
   this.type = this.node?.type;
 }
 
diff --git a/packages/babel-traverse/src/path/conversion.ts b/packages/babel-traverse/src/path/conversion.ts
index e2740d9c19cd..d5156950d232 100644
--- a/packages/babel-traverse/src/path/conversion.ts
+++ b/packages/babel-traverse/src/path/conversion.ts
@@ -94,7 +94,10 @@ export function ensureBlock(
   const parentPath = this.get(stringPath) as NodePath;
   body.setup(
     parentPath,
-    listKey ? parentPath.node[listKey] : parentPath.node,
+    listKey
+      ? // @ts-expect-error listKey must present in parent path
+        parentPath.node[listKey]
+      : parentPath.node,
     listKey,
     key,
   );
@@ -136,7 +139,7 @@ export function unwrapFunctionEnvironment(this: NodePath) {
  * Convert a given arrow function into a normal ES5 function expression.
  */
 export function arrowFunctionToExpression(
-  this: NodePath,
+  this: NodePath<t.ArrowFunctionExpression>,
   {
     allowInsertArrow = true,
     /** @deprecated Use `noNewArrows` instead */
@@ -150,7 +153,7 @@ export function arrowFunctionToExpression(
   } = {},
 ) {
   if (!this.isArrowFunctionExpression()) {
-    throw this.buildCodeFrameError(
+    throw (this as NodePath).buildCodeFrameError(
       "Cannot convert non-arrow function to a function expression.",
     );
   }
@@ -161,6 +164,7 @@ export function arrowFunctionToExpression(
     allowInsertArrow,
   );
 
+  // @ts-expect-error TS requires explicit fn type annotation
   fn.ensureBlock();
   fn.node.type = "FunctionExpression";
   if (!noNewArrows) {
@@ -174,7 +178,7 @@ export function arrowFunctionToExpression(
       });
     }
 
-    fn.get("body").unshiftContainer(
+    (fn.get("body") as NodePath<t.BlockStatement>).unshiftContainer(
       "body",
       expressionStatement(
         callExpression(this.hub.addHelper("newArrowCheck"), [
@@ -189,6 +193,7 @@ export function arrowFunctionToExpression(
     fn.replaceWith(
       callExpression(
         memberExpression(
+          // @ts-expect-error TS can't infer nameFunction returns CallExpression | ArrowFunctionExpression here
           nameFunction(this, true) || fn.node,
           identifier("bind"),
         ),
@@ -225,7 +230,7 @@ function hoistFunctionEnvironment(
   allowInsertArrow: boolean | void = true,
 ): { thisBinding: string; fnPath: NodePath<t.Function> } {
   let arrowParent;
-  let thisEnvFn = fnPath.findParent(p => {
+  let thisEnvFn: NodePath<t.Function> = fnPath.findParent(p => {
     if (p.isArrowFunctionExpression()) {
       arrowParent ??= p;
       return false;
@@ -236,7 +241,7 @@ function hoistFunctionEnvironment(
       p.isClassProperty({ static: false }) ||
       p.isClassPrivateProperty({ static: false })
     );
-  });
+  }) as NodePath<t.Function>;
   const inConstructor = thisEnvFn.isClassMethod({ kind: "constructor" });
 
   if (thisEnvFn.isClassProperty() || thisEnvFn.isClassPrivateProperty()) {
@@ -253,8 +258,8 @@ function hoistFunctionEnvironment(
           [],
         ),
       );
-      thisEnvFn = fnPath.get("callee");
-      fnPath = thisEnvFn.get("body");
+      thisEnvFn = fnPath.get("callee") as NodePath<t.ArrowFunctionExpression>;
+      fnPath = thisEnvFn.get("body") as NodePath<t.FunctionExpression>;
     } else {
       throw fnPath.buildCodeFrameError(
         "Unable to transform arrow inside class property",
@@ -332,7 +337,7 @@ function hoistFunctionEnvironment(
       );
     }
 
-    const flatSuperProps = superProps.reduce(
+    const flatSuperProps: NodePath<t.MemberExpression>[] = superProps.reduce(
       (acc, superProp) => acc.concat(standardizeSuperProperty(superProp)),
       [],
     );
@@ -340,36 +345,42 @@ function hoistFunctionEnvironment(
     flatSuperProps.forEach(superProp => {
       const key = superProp.node.computed
         ? ""
-        : superProp.get("property").node.name;
+        : // @ts-expect-error super property must not contain private name
+          superProp.get("property").node.name;
+
+      const superParentPath = superProp.parentPath;
 
-      const isAssignment = superProp.parentPath.isAssignmentExpression({
+      const isAssignment = superParentPath.isAssignmentExpression({
         left: superProp.node,
       });
-      const isCall = superProp.parentPath.isCallExpression({
+      const isCall = superParentPath.isCallExpression({
         callee: superProp.node,
       });
       const superBinding = getSuperPropBinding(thisEnvFn, isAssignment, key);
 
-      const args = [];
+      const args: t.Expression[] = [];
       if (superProp.node.computed) {
-        args.push(superProp.get("property").node);
+        // SuperProperty must not be a private name
+        args.push(superProp.get("property").node as t.Expression);
       }
 
       if (isAssignment) {
-        const value = superProp.parentPath.node.right;
+        const value = superParentPath.node.right;
         args.push(value);
       }
 
       const call = callExpression(identifier(superBinding), args);
 
       if (isCall) {
-        superProp.parentPath.unshiftContainer("arguments", thisExpression());
+        superParentPath.unshiftContainer("arguments", thisExpression());
         superProp.replaceWith(memberExpression(call, identifier("call")));
 
-        thisPaths.push(superProp.parentPath.get("arguments.0"));
+        thisPaths.push(
+          superParentPath.get("arguments.0") as NodePath<t.ThisExpression>,
+        );
       } else if (isAssignment) {
         // Replace not only the super.prop, but the whole assignment
-        superProp.parentPath.replaceWith(call);
+        superParentPath.replaceWith(call);
       } else {
         superProp.replaceWith(call);
       }
@@ -377,7 +388,7 @@ function hoistFunctionEnvironment(
   }
 
   // Convert all "this" references in the arrow to point at the alias.
-  let thisBinding;
+  let thisBinding: string | null;
   if (thisPaths.length > 0 || !noNewArrows) {
     thisBinding = getThisBinding(thisEnvFn, inConstructor);
 
@@ -410,7 +421,11 @@ function isLogicalOp(op: string): op is LogicalOp {
   return LOGICAL_OPERATORS.includes(op);
 }
 
-function standardizeSuperProperty(superProp: NodePath<t.MemberExpression>) {
+function standardizeSuperProperty(
+  superProp: NodePath<t.MemberExpression>,
+):
+  | [NodePath<t.MemberExpression>]
+  | [NodePath<t.MemberExpression>, NodePath<t.MemberExpression>] {
   if (
     superProp.parentPath.isAssignmentExpression() &&
     superProp.parentPath.node.operator !== "="
@@ -485,7 +500,7 @@ function standardizeSuperProperty(superProp: NodePath<t.MemberExpression>) {
       assignmentPath.replaceWith(
         logicalExpression(
           op,
-          assignmentPath.node.left as t.Expression,
+          assignmentPath.node.left as t.MemberExpression,
           assignmentPath.node.right as t.Expression,
         ),
       );
@@ -494,7 +509,7 @@ function standardizeSuperProperty(superProp: NodePath<t.MemberExpression>) {
     }
 
     return [
-      assignmentPath.get("left"),
+      assignmentPath.get("left") as NodePath<t.MemberExpression>,
       assignmentPath.get("right").get("left"),
     ];
   } else if (superProp.parentPath.isUpdateExpression()) {
@@ -543,8 +558,12 @@ function standardizeSuperProperty(superProp: NodePath<t.MemberExpression>) {
 
     updateExpr.replaceWith(sequenceExpression(parts));
 
-    const left = updateExpr.get("expressions.0.right");
-    const right = updateExpr.get("expressions.1.left");
+    const left = updateExpr.get(
+      "expressions.0.right",
+    ) as NodePath<t.MemberExpression>;
+    const right = updateExpr.get(
+      "expressions.1.left",
+    ) as NodePath<t.MemberExpression>;
     return [left, right];
   }
 
@@ -563,10 +582,10 @@ function standardizeSuperProperty(superProp: NodePath<t.MemberExpression>) {
   }
 }
 
-function hasSuperClass(thisEnvFn) {
+function hasSuperClass(thisEnvFn: NodePath<t.Function>) {
   return (
     thisEnvFn.isClassMethod() &&
-    !!thisEnvFn.parentPath.parentPath.node.superClass
+    !!(thisEnvFn.parentPath.parentPath.node as t.Class).superClass
   );
 }
 
@@ -590,7 +609,10 @@ const assignSuperThisVisitor = mergeVisitors<{
 ]);
 
 // Create a binding that evaluates to the "this" of the given function.
-function getThisBinding(thisEnvFn, inConstructor) {
+function getThisBinding(
+  thisEnvFn: NodePath<t.Function>,
+  inConstructor: boolean,
+) {
   return getBinding(thisEnvFn, "this", thisBinding => {
     if (!inConstructor || !hasSuperClass(thisEnvFn)) return thisExpression();
 
@@ -602,7 +624,7 @@ function getThisBinding(thisEnvFn, inConstructor) {
 }
 
 // Create a binding for a function that will call "super()" with arguments passed through.
-function getSuperBinding(thisEnvFn) {
+function getSuperBinding(thisEnvFn: NodePath<t.Function>) {
   return getBinding(thisEnvFn, "supercall", () => {
     const argsBinding = thisEnvFn.scope.generateUidIdentifier("args");
     return arrowFunctionExpression(
@@ -613,7 +635,11 @@ function getSuperBinding(thisEnvFn) {
 }
 
 // Create a binding for a function that will call "super.foo" or "super[foo]".
-function getSuperPropBinding(thisEnvFn, isAssignment, propName) {
+function getSuperPropBinding(
+  thisEnvFn: NodePath<t.Function>,
+  isAssignment: boolean,
+  propName: string,
+) {
   const op = isAssignment ? "set" : "get";
 
   return getBinding(thisEnvFn, `superprop_${op}:${propName || ""}`, () => {
@@ -645,9 +671,13 @@ function getSuperPropBinding(thisEnvFn, isAssignment, propName) {
   });
 }
 
-function getBinding(thisEnvFn, key, init) {
+function getBinding(
+  thisEnvFn: NodePath,
+  key: string,
+  init: (name: string) => t.Expression,
+) {
   const cacheKey = "binding:" + key;
-  let data = thisEnvFn.getData(cacheKey);
+  let data: string | undefined = thisEnvFn.getData(cacheKey);
   if (!data) {
     const id = thisEnvFn.scope.generateUidIdentifier(key);
     data = id.name;
@@ -662,13 +692,15 @@ function getBinding(thisEnvFn, key, init) {
   return data;
 }
 
-const getScopeInformationVisitor = mergeVisitors<{
+type ScopeInfo = {
   thisPaths: NodePath<t.ThisExpression | t.JSXIdentifier>[];
   superCalls: NodePath<t.CallExpression>[];
   superProps: NodePath<t.MemberExpression>[];
   argumentsPaths: NodePath<t.Identifier | t.JSXIdentifier>[];
   newTargetPaths: NodePath<t.MetaProperty>[];
-}>([
+};
+
+const getScopeInformationVisitor = mergeVisitors<ScopeInfo>([
   {
     ThisExpression(child, { thisPaths }) {
       thisPaths.push(child);
@@ -716,12 +748,12 @@ const getScopeInformationVisitor = mergeVisitors<{
   environmentVisitor,
 ]);
 
-function getScopeInformation(fnPath) {
-  const thisPaths = [];
-  const argumentsPaths = [];
-  const newTargetPaths = [];
-  const superProps = [];
-  const superCalls = [];
+function getScopeInformation(fnPath: NodePath) {
+  const thisPaths: ScopeInfo["thisPaths"] = [];
+  const argumentsPaths: ScopeInfo["argumentsPaths"] = [];
+  const newTargetPaths: ScopeInfo["newTargetPaths"] = [];
+  const superProps: ScopeInfo["superProps"] = [];
+  const superCalls: ScopeInfo["superCalls"] = [];
 
   fnPath.traverse(getScopeInformationVisitor, {
     thisPaths,
diff --git a/packages/babel-traverse/src/path/evaluation.ts b/packages/babel-traverse/src/path/evaluation.ts
index 89541ccd78c8..0accebc030ae 100644
--- a/packages/babel-traverse/src/path/evaluation.ts
+++ b/packages/babel-traverse/src/path/evaluation.ts
@@ -1,9 +1,24 @@
 import type NodePath from "./index";
+import type * as t from "@babel/types";
 
 // This file contains Babels metainterpreter that can evaluate static code.
 
-const VALID_CALLEES = ["String", "Number", "Math"];
-const INVALID_METHODS = ["random"];
+const VALID_CALLEES = ["String", "Number", "Math"] as const;
+const INVALID_METHODS = ["random"] as const;
+
+function isValidCallee(val: string): val is typeof VALID_CALLEES[number] {
+  return VALID_CALLEES.includes(
+    // @ts-expect-error
+    val,
+  );
+}
+
+function isInvalidMethod(val: string): val is typeof INVALID_METHODS[number] {
+  return INVALID_METHODS.includes(
+    // @ts-expect-error
+    val,
+  );
+}
 
 /**
  * Walk the input `node` and statically evaluate if it's truthy.
@@ -28,10 +43,20 @@ export function evaluateTruthy(this: NodePath): boolean {
   if (res.confident) return !!res.value;
 }
 
+type State = {
+  confident: boolean;
+  deoptPath: NodePath | null;
+  seen: Map<t.Node, Result>;
+};
+
+type Result = {
+  resolved: boolean;
+  value?: any;
+};
 /**
  * Deopts the evaluation
  */
-function deopt(path, state) {
+function deopt(path: NodePath, state: State) {
   if (!state.confident) return;
   state.deoptPath = path;
   state.confident = false;
@@ -45,7 +70,7 @@ function deopt(path, state) {
  *   var g = a ? 1 : 2,
  *       a = g * this.foo
  */
-function evaluateCached(path: NodePath, state) {
+function evaluateCached(path: NodePath, state: State): any {
   const { node } = path;
   const { seen } = state;
 
@@ -58,8 +83,7 @@ function evaluateCached(path: NodePath, state) {
       return;
     }
   } else {
-    // todo: create type annotation for state instead
-    const item: { resolved: boolean; value?: any } = { resolved: false };
+    const item: Result = { resolved: false };
     seen.set(node, item);
 
     const val = _evaluate(path, state);
@@ -71,7 +95,7 @@ function evaluateCached(path: NodePath, state) {
   }
 }
 
-function _evaluate(path: NodePath, state) {
+function _evaluate(path: NodePath, state: State): any {
   if (!state.confident) return;
 
   if (path.isSequenceExpression()) {
@@ -256,6 +280,7 @@ function _evaluate(path: NodePath, state) {
         return deopt(value.deopt, state);
       }
       value = value.value;
+      // @ts-expect-error
       obj[key] = value;
     }
     return obj;
@@ -346,7 +371,7 @@ function _evaluate(path: NodePath, state) {
     if (
       callee.isIdentifier() &&
       !path.scope.getBinding(callee.node.name) &&
-      VALID_CALLEES.indexOf(callee.node.name) >= 0
+      isValidCallee(callee.node.name)
     ) {
       func = global[callee.node.name];
     }
@@ -359,10 +384,11 @@ function _evaluate(path: NodePath, state) {
       if (
         object.isIdentifier() &&
         property.isIdentifier() &&
-        VALID_CALLEES.indexOf(object.node.name) >= 0 &&
-        INVALID_METHODS.indexOf(property.node.name) < 0
+        isValidCallee(object.node.name) &&
+        !isInvalidMethod(property.node.name)
       ) {
         context = global[object.node.name];
+        // @ts-ignore property may not exist in context object
         func = context[property.node.name];
       }
 
@@ -389,7 +415,12 @@ function _evaluate(path: NodePath, state) {
   deopt(path, state);
 }
 
-function evaluateQuasis(path, quasis: Array<any>, state, raw = false) {
+function evaluateQuasis(
+  path: NodePath<t.TaggedTemplateExpression | t.TemplateLiteral>,
+  quasis: Array<any>,
+  state: State,
+  raw = false,
+) {
   let str = "";
 
   let i = 0;
@@ -432,7 +463,7 @@ export function evaluate(this: NodePath): {
   value: any;
   deopt?: NodePath;
 } {
-  const state = {
+  const state: State = {
     confident: true,
     deoptPath: null,
     seen: new Map(),
diff --git a/packages/babel-traverse/src/path/family.ts b/packages/babel-traverse/src/path/family.ts
index d50bacf908e9..e292e03e9d5a 100644
--- a/packages/babel-traverse/src/path/family.ts
+++ b/packages/babel-traverse/src/path/family.ts
@@ -11,8 +11,8 @@ import {
 } from "@babel/types";
 import type * as t from "@babel/types";
 
-const NORMAL_COMPLETION = 0;
-const BREAK_COMPLETION = 1;
+const NORMAL_COMPLETION = 0 as const;
+const BREAK_COMPLETION = 1 as const;
 
 type Completion = {
   path: NodePath;
@@ -65,7 +65,7 @@ function completionRecordForSwitch(
   context: CompletionContext,
 ): Completion[] {
   // https://tc39.es/ecma262/#sec-runtime-semantics-caseblockevaluation
-  let lastNormalCompletions = [];
+  let lastNormalCompletions: Completion[] = [];
   for (let i = 0; i < cases.length; i++) {
     const casePath = cases[i];
     const caseCompletions = _getCompletionRecords(casePath, context);
@@ -227,7 +227,7 @@ function _getCompletionRecords(
   path: NodePath,
   context: CompletionContext,
 ): Completion[] {
-  let records = [];
+  let records: Completion[] = [];
   if (path.isIfStatement()) {
     records = addCompletionRecords(path.get("consequent"), records, context);
     records = addCompletionRecords(path.get("alternate"), records, context);
@@ -413,7 +413,9 @@ export function _getKey<T extends t.Node>(
   context?: TraversalContext,
 ): NodePath | NodePath[] {
   const node = this.node;
-  const container = node[key];
+  const container =
+    // @ts-ignore
+    node[key];
 
   if (Array.isArray(container)) {
     // requested a container so give them all the paths
@@ -448,6 +450,7 @@ export function _getPattern(
       path = path.parentPath;
     } else {
       if (Array.isArray(path)) {
+        // @ts-ignore
         path = path[part];
       } else {
         path = path.get(part, context);
@@ -503,7 +506,8 @@ export function getBindingIdentifierPaths(
   duplicates: boolean = false,
   outerOnly: boolean = false,
 ): {
-  [x: string]: NodePath;
+  // todo: returns NodePath<t.Identifier>[] when duplicates is true
+  [x: string]: NodePath<t.Identifier>;
 } {
   const path = this;
   const search = [path];
@@ -514,7 +518,9 @@ export function getBindingIdentifierPaths(
     if (!id) continue;
     if (!id.node) continue;
 
-    const keys = _getBindingIdentifiers.keys[id.node.type];
+    const keys =
+      // @ts-ignore
+      _getBindingIdentifiers.keys[id.node.type];
 
     if (id.isIdentifier()) {
       if (duplicates) {
@@ -564,8 +570,6 @@ export function getBindingIdentifierPaths(
 export function getOuterBindingIdentifierPaths(
   this: NodePath,
   duplicates?: boolean,
-): {
-  [x: string]: NodePath;
-} {
+) {
   return this.getBindingIdentifierPaths(duplicates, true);
 }
diff --git a/packages/babel-traverse/src/path/index.ts b/packages/babel-traverse/src/path/index.ts
index 4b999a3ab1da..ec9dceeaf560 100644
--- a/packages/babel-traverse/src/path/index.ts
+++ b/packages/babel-traverse/src/path/index.ts
@@ -43,7 +43,8 @@ class NodePath<T extends t.Node = t.Node> {
 
   declare parent: t.Node;
   declare hub: HubInterface;
-  declare data: object;
+  declare data: Record<string | symbol, unknown>;
+  // TraversalContext is configured by setContext
   declare context: TraversalContext;
   declare scope: Scope;
 
@@ -54,7 +55,7 @@ class NodePath<T extends t.Node = t.Node> {
   _traverseFlags: number = 0;
   skipKeys: any = null;
   parentPath: NodePath | null = null;
-  container: object | null | Array<any> = null;
+  container: t.Node | Array<t.Node> | null = null;
   listKey: string | null = null;
   key: string | number | null = null;
   node: T = null;
@@ -68,12 +69,12 @@ class NodePath<T extends t.Node = t.Node> {
     listKey,
     key,
   }: {
-    hub?;
-    parentPath;
-    parent;
-    container;
-    listKey?;
-    key;
+    hub?: HubInterface;
+    parentPath: NodePath | null;
+    parent: t.Node;
+    container: t.Node | t.Node[];
+    listKey?: string;
+    key: string | number;
   }): NodePath {
     if (!hub && parentPath) {
       hub = parentPath.hub;
@@ -83,7 +84,9 @@ class NodePath<T extends t.Node = t.Node> {
       throw new Error("To get a node path the parent needs to exist");
     }
 
-    const targetNode = container[key];
+    const targetNode =
+      // @ts-ignore key must present in container
+      container[key];
 
     let paths = pathCache.get(parent);
     if (!paths) {
@@ -102,7 +105,7 @@ class NodePath<T extends t.Node = t.Node> {
     return path;
   }
 
-  getScope(scope: Scope) {
+  getScope(scope: Scope): Scope {
     return this.isScope() ? new Scope(this) : scope;
   }
 
@@ -141,6 +144,7 @@ class NodePath<T extends t.Node = t.Node> {
 
   set(key: string, node: any) {
     validate(this.node, key, node);
+    // @ts-expect-error key must present in this.node
     this.node[key] = node;
   }
 
@@ -155,7 +159,7 @@ class NodePath<T extends t.Node = t.Node> {
     return parts.join(".");
   }
 
-  debug(message) {
+  debug(message: string) {
     if (!debug.enabled) return;
     debug(`${this.getPathLocation()} ${this.type}: ${message}`);
   }
@@ -175,8 +179,8 @@ class NodePath<T extends t.Node = t.Node> {
     // ignore inList = true as it should depend on `listKey`
   }
 
-  get parentKey() {
-    return this.listKey || this.key;
+  get parentKey(): string {
+    return (this.listKey || this.key) as string;
   }
 
   get shouldSkip() {
@@ -245,25 +249,29 @@ if (!process.env.BABEL_8_BREAKING) {
 // we can change to `import { TYPES }` when we are publishing ES modules only
 for (const type of t.TYPES) {
   const typeKey = `is${type}`;
+  // @ts-expect-error typeKey must present in t
   const fn = t[typeKey];
-  NodePath.prototype[typeKey] = function (opts) {
+  // @ts-expect-error augmenting NodePath prototype
+  NodePath.prototype[typeKey] = function (opts: any) {
     return fn(this.node, opts);
   };
 
-  NodePath.prototype[`assert${type}`] = function (opts) {
+  // @ts-expect-error augmenting NodePath prototype
+  NodePath.prototype[`assert${type}`] = function (opts: any) {
     if (!fn(this.node, opts)) {
       throw new TypeError(`Expected node path of type ${type}`);
     }
   };
 }
 
-for (const type of Object.keys(virtualTypes)) {
+for (const type of Object.keys(virtualTypes) as (keyof typeof virtualTypes)[]) {
   if (type[0] === "_") continue;
   if (t.TYPES.indexOf(type) < 0) t.TYPES.push(type);
 
   const virtualType = virtualTypes[type];
 
   NodePath.prototype[`is${type}`] = function (opts) {
+    // @ts-expect-error checkPath will throw when type is ExistentialTypeParam/NumericLiteralTypeAnnotation
     return virtualType.checkPath(this, opts);
   };
 }
@@ -280,10 +288,28 @@ type NodePathMixins = typeof NodePath_ancestry &
   typeof NodePath_family &
   typeof NodePath_comments;
 
+// @ts-ignore TS throws because ensureBlock returns the body node path
+// however, we don't use the return value and treat it as a transform and
+// assertion utilities. For better type inference we annotate it as an
+// assertion method
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 interface NodePath<T>
   extends NodePathAssetions,
     NodePathValidators,
-    NodePathMixins {}
+    NodePathMixins {
+  /**
+   * @see ./conversion.ts for implementation
+   */
+  ensureBlock<
+    T extends
+      | t.Loop
+      | t.WithStatement
+      | t.Function
+      | t.LabeledStatement
+      | t.CatchClause,
+  >(
+    this: NodePath<T>,
+  ): asserts this is NodePath<T & { body: t.BlockStatement }>;
+}
 
 export default NodePath;
diff --git a/packages/babel-traverse/src/path/inference/index.ts b/packages/babel-traverse/src/path/inference/index.ts
index 384ee29d3e42..ccc073292ccb 100644
--- a/packages/babel-traverse/src/path/inference/index.ts
+++ b/packages/babel-traverse/src/path/inference/index.ts
@@ -81,11 +81,14 @@ export function _getTypeAnnotation(this: NodePath): any {
   typeAnnotationInferringNodes.add(node);
 
   try {
-    let inferer = inferers[node.type];
+    let inferer =
+      // @ts-expect-error inferers do not cover all AST types
+      inferers[node.type];
     if (inferer) {
       return inferer.call(this, node);
     }
 
+    // @ts-expect-error inferers do not cover all AST types
     inferer = inferers[this.parentPath.type];
     if (inferer?.validParent) {
       return this.parentPath.getTypeAnnotation();
@@ -103,7 +106,11 @@ export function isBaseType(
   return _isBaseType(baseName, this.getTypeAnnotation(), soft);
 }
 
-function _isBaseType(baseName: string, type?, soft?): boolean {
+function _isBaseType(
+  baseName: string,
+  type?: t.FlowType,
+  soft?: boolean,
+): boolean {
   if (baseName === "string") {
     return isStringTypeAnnotation(type);
   } else if (baseName === "number") {
diff --git a/packages/babel-traverse/src/path/inference/inferer-reference.ts b/packages/babel-traverse/src/path/inference/inferer-reference.ts
index 5882abf9107f..baf9ecf17000 100644
--- a/packages/babel-traverse/src/path/inference/inferer-reference.ts
+++ b/packages/babel-traverse/src/path/inference/inferer-reference.ts
@@ -12,7 +12,7 @@ import {
 import type * as t from "@babel/types";
 import type Binding from "../../scope/binding";
 
-export default function (this: NodePath, node: any) {
+export default function (this: NodePath<t.Identifier>, node: t.Identifier) {
   if (!this.isReferenced()) return;
 
   // check if a binding exists of this value and if so then return a union type of all
@@ -40,10 +40,14 @@ export default function (this: NodePath, node: any) {
   }
 }
 
-function getTypeAnnotationBindingConstantViolations(binding, path, name) {
+function getTypeAnnotationBindingConstantViolations(
+  binding: Binding,
+  path: NodePath<t.Identifier>,
+  name: string,
+) {
   const types = [];
 
-  const functionConstantViolations = [];
+  const functionConstantViolations: NodePath[] = [];
   let constantViolations = getConstantViolationsBefore(
     binding,
     path,
@@ -107,17 +111,24 @@ function getTypeAnnotationBindingConstantViolations(binding, path, name) {
   }
 
   if (isTSTypeAnnotation(types[0]) && createTSUnionType) {
-    return createTSUnionType(types);
+    return createTSUnionType(
+      // @ts-ignore fixme: createTSUnionType should handle voidTypeAnnotation
+      types as t.TSTypeAnnotation[],
+    );
   }
 
   if (createFlowUnionType) {
-    return createFlowUnionType(types);
+    return createFlowUnionType(types as t.FlowType[]);
   }
 
-  return createUnionTypeAnnotation(types);
+  return createUnionTypeAnnotation(types as t.FlowType[]);
 }
 
-function getConstantViolationsBefore(binding: Binding, path, functions?) {
+function getConstantViolationsBefore(
+  binding: Binding,
+  path: NodePath,
+  functions?: NodePath[],
+) {
   const violations = binding.constantViolations.slice();
   violations.unshift(binding.path);
   return violations.filter(violation => {
@@ -186,7 +197,11 @@ function inferAnnotationFromBinaryExpression(
   return createTypeAnnotationBasedOnTypeof(typeValue);
 }
 
-function getParentConditionalPath(binding, path, name) {
+function getParentConditionalPath(
+  binding: Binding,
+  path: NodePath,
+  name: string,
+) {
   let parentPath;
   while ((parentPath = path.parentPath)) {
     if (parentPath.isIfStatement() || parentPath.isConditionalExpression()) {
@@ -194,7 +209,7 @@ function getParentConditionalPath(binding, path, name) {
         return;
       }
 
-      return parentPath;
+      return parentPath as NodePath<t.IfStatement | t.ConditionalExpression>;
     }
     if (parentPath.isFunction()) {
       if (parentPath.parentPath.scope.getBinding(name) !== binding) return;
@@ -207,8 +222,11 @@ function getParentConditionalPath(binding, path, name) {
 function getConditionalAnnotation<T extends t.Node>(
   binding: Binding,
   path: NodePath<T>,
-  name?,
-) {
+  name?: string,
+): {
+  typeAnnotation: t.FlowType | t.TSType;
+  ifStatement: NodePath<t.IfStatement | t.ConditionalExpression>;
+} {
   const ifStatement = getParentConditionalPath(binding, path, name);
   if (!ifStatement) return;
 
@@ -233,7 +251,10 @@ function getConditionalAnnotation<T extends t.Node>(
   if (types.length) {
     if (isTSTypeAnnotation(types[0]) && createTSUnionType) {
       return {
-        typeAnnotation: createTSUnionType(types),
+        typeAnnotation: createTSUnionType(
+          // @ts-ignore fixme: createTSUnionType should handle voidTypeAnnotation
+          types as t.TSTypeAnnotation[],
+        ),
         ifStatement,
       };
     }
@@ -251,5 +272,5 @@ function getConditionalAnnotation<T extends t.Node>(
     };
   }
 
-  return getConditionalAnnotation(ifStatement, name);
+  return getConditionalAnnotation(binding, ifStatement, name);
 }
diff --git a/packages/babel-traverse/src/path/inference/inferers.ts b/packages/babel-traverse/src/path/inference/inferers.ts
index 14e95ebd99f5..c2d0813029be 100644
--- a/packages/babel-traverse/src/path/inference/inferers.ts
+++ b/packages/babel-traverse/src/path/inference/inferers.ts
@@ -49,14 +49,17 @@ export function VariableDeclarator(this: NodePath<t.VariableDeclarator>) {
   return type;
 }
 
-export function TypeCastExpression(node) {
+export function TypeCastExpression(node: t.TypeCastExpression) {
   return node.typeAnnotation;
 }
 
 TypeCastExpression.validParent = true;
 
-export function NewExpression(this: NodePath<t.NewExpression>, node) {
-  if (this.get("callee").isIdentifier()) {
+export function NewExpression(
+  this: NodePath<t.NewExpression>,
+  node: t.NewExpression,
+) {
+  if (node.callee.type === "Identifier") {
     // only resolve identifier callee
     return genericTypeAnnotation(node.callee);
   }
@@ -66,7 +69,7 @@ export function TemplateLiteral() {
   return stringTypeAnnotation();
 }
 
-export function UnaryExpression(node) {
+export function UnaryExpression(node: t.UnaryExpression) {
   const operator = node.operator;
 
   if (operator === "void") {
@@ -80,7 +83,10 @@ export function UnaryExpression(node) {
   }
 }
 
-export function BinaryExpression(this: NodePath<t.BinaryExpression>, node) {
+export function BinaryExpression(
+  this: NodePath<t.BinaryExpression>,
+  node: t.BinaryExpression,
+) {
   const operator = node.operator;
 
   if (NUMBER_BINARY_OPERATORS.indexOf(operator) >= 0) {
@@ -157,7 +163,10 @@ export function AssignmentExpression(this: NodePath<t.AssignmentExpression>) {
   return this.get("right").getTypeAnnotation();
 }
 
-export function UpdateExpression(this: NodePath<t.UpdateExpression>, node) {
+export function UpdateExpression(
+  this: NodePath<t.UpdateExpression>,
+  node: t.UpdateExpression,
+) {
   const operator = node.operator;
   if (operator === "++" || operator === "--") {
     return numberTypeAnnotation();
@@ -235,7 +244,7 @@ export function TaggedTemplateExpression(
   return resolveCall(this.get("tag"));
 }
 
-function resolveCall(callee) {
+function resolveCall(callee: NodePath) {
   callee = callee.resolve();
 
   if (callee.isFunction()) {
diff --git a/packages/babel-traverse/src/path/introspection.ts b/packages/babel-traverse/src/path/introspection.ts
index 0fbf09a5b7d8..8fc635d7c6c6 100644
--- a/packages/babel-traverse/src/path/introspection.ts
+++ b/packages/babel-traverse/src/path/introspection.ts
@@ -35,7 +35,10 @@ export function matchesPattern(
  */
 
 export function has(this: NodePath, key: string): boolean {
-  const val = this.node && this.node[key];
+  const val =
+    this.node &&
+    // @ts-ignore
+    this.node[key];
   if (val && Array.isArray(val)) {
     return !!val.length;
   } else {
@@ -69,7 +72,8 @@ export function isnt(this: NodePath, key: string): boolean {
  * Check whether the path node `key` strict equals `value`.
  */
 
-export function equals(this: NodePath, key: string, value): boolean {
+export function equals(this: NodePath, key: string, value: any): boolean {
+  // @ts-ignore
   return this.node[key] === value;
 }
 
@@ -249,15 +253,18 @@ export function getSource(this: NodePath): string {
   return "";
 }
 
-export function willIMaybeExecuteBefore(this: NodePath, target): boolean {
+export function willIMaybeExecuteBefore(
+  this: NodePath,
+  target: NodePath,
+): boolean {
   return this._guessExecutionStatusRelativeTo(target) !== "after";
 }
 
-function getOuterFunction(path) {
+function getOuterFunction(path: NodePath) {
   return (path.scope.getFunctionParent() || path.scope.getProgramParent()).path;
 }
 
-function isExecutionUncertain(type, key) {
+function isExecutionUncertain(type: t.Node["type"], key: string) {
   switch (type) {
     // a && FOO
     // a || FOO
@@ -306,7 +313,7 @@ function isExecutionUncertain(type, key) {
   }
 }
 
-function isExecutionUncertainInList(paths, maxIndex) {
+function isExecutionUncertainInList(paths: NodePath[], maxIndex: number) {
   for (let i = 0; i < maxIndex; i++) {
     const path = paths[i];
     if (isExecutionUncertain(path.parent.type, path.parentKey)) {
@@ -509,14 +516,18 @@ function _guessExecutionStatusRelativeToDifferentFunctionsCached(
 /**
  * Resolve a "pointer" `NodePath` to it's absolute path.
  */
-export function resolve(this: NodePath, dangerous?, resolved?) {
+export function resolve(
+  this: NodePath,
+  dangerous?: boolean,
+  resolved?: NodePath[],
+) {
   return this._resolve(dangerous, resolved) || this;
 }
 
 export function _resolve(
   this: NodePath,
-  dangerous?,
-  resolved?,
+  dangerous?: boolean,
+  resolved?: NodePath[],
 ): NodePath | undefined | null {
   // detect infinite recursion
   // todo: possibly have a max length on this just to be safe
@@ -587,7 +598,7 @@ export function _resolve(
   }
 }
 
-export function isConstantExpression(this: NodePath) {
+export function isConstantExpression(this: NodePath): boolean {
   if (this.isIdentifier()) {
     const binding = this.scope.getBinding(this.node.name);
     if (!binding) return false;
diff --git a/packages/babel-traverse/src/path/lib/hoister.ts b/packages/babel-traverse/src/path/lib/hoister.ts
index 635b78f2feb3..c0876436d1f5 100644
--- a/packages/babel-traverse/src/path/lib/hoister.ts
+++ b/packages/babel-traverse/src/path/lib/hoister.ts
@@ -87,7 +87,7 @@ export default class PathHoister<T extends t.Node = t.Node> {
   }
 
   // A scope is compatible if all required bindings are reachable.
-  isCompatibleScope(scope) {
+  isCompatibleScope(scope: Scope) {
     for (const key of Object.keys(this.bindings)) {
       const binding = this.bindings[key];
       if (!scope.bindingIdentifierEquals(key, binding.identifier)) {
@@ -198,7 +198,7 @@ export default class PathHoister<T extends t.Node = t.Node> {
   }
 
   // Find an attachment for this path.
-  getAttachmentParentForPath(path) {
+  getAttachmentParentForPath(path: NodePath) {
     do {
       if (
         // Beginning of the scope
@@ -212,7 +212,7 @@ export default class PathHoister<T extends t.Node = t.Node> {
   }
 
   // Returns true if a scope has param bindings.
-  hasOwnParamBindings(scope) {
+  hasOwnParamBindings(scope: Scope) {
     for (const name of Object.keys(this.bindings)) {
       if (!scope.hasOwnBinding(name)) continue;
 
@@ -238,7 +238,8 @@ export default class PathHoister<T extends t.Node = t.Node> {
     if (attachTo.getFunctionParent() === this.path.getFunctionParent()) return;
 
     // generate declaration and insert it to our point
-    let uid = attachTo.scope.generateUidIdentifier("ref");
+    let uid: t.Identifier | t.JSXExpressionContainer =
+      attachTo.scope.generateUidIdentifier("ref");
 
     // @ts-expect-error todo(flow->ts): more specific type for this.path
     const declarator = variableDeclarator(uid, this.path.node);
diff --git a/packages/babel-traverse/src/path/lib/removal-hooks.ts b/packages/babel-traverse/src/path/lib/removal-hooks.ts
index 20d7fba20e6e..7872299b4f0c 100644
--- a/packages/babel-traverse/src/path/lib/removal-hooks.ts
+++ b/packages/babel-traverse/src/path/lib/removal-hooks.ts
@@ -1,11 +1,13 @@
 // this file contains hooks that handle ancestry cleanup of parent nodes when removing children
 
+import NodePath from "..";
+import type * as t from "@babel/types";
 /**
  * Pre hooks should be used for either rejecting removal or delegating removal
  */
 
 export const hooks = [
-  function (self, parent) {
+  function (self: NodePath, parent: NodePath) {
     const removeParent =
       // while (NODE);
       // removing the test of a while/switch, we can either just remove it entirely *or* turn the
@@ -33,7 +35,7 @@ export const hooks = [
     }
   },
 
-  function (self, parent) {
+  function (self: NodePath, parent: NodePath) {
     if (parent.isSequenceExpression() && parent.node.expressions.length === 1) {
       // (node, NODE);
       // we've just removed the second element of a sequence expression so let's turn that sequence
@@ -43,7 +45,7 @@ export const hooks = [
     }
   },
 
-  function (self, parent) {
+  function (self: NodePath, parent: NodePath) {
     if (parent.isBinary()) {
       // left + NODE;
       // NODE + right;
@@ -58,7 +60,7 @@ export const hooks = [
     }
   },
 
-  function (self, parent) {
+  function (self: NodePath, parent: NodePath) {
     if (
       (parent.isIfStatement() &&
         (self.key === "consequent" || self.key === "alternate")) ||
@@ -68,7 +70,7 @@ export const hooks = [
       self.replaceWith({
         type: "BlockStatement",
         body: [],
-      });
+      } as t.BlockStatement);
       return true;
     }
   },
diff --git a/packages/babel-traverse/src/path/lib/virtual-types.ts b/packages/babel-traverse/src/path/lib/virtual-types.ts
index d08fd554eeef..3acf1ba5ebba 100644
--- a/packages/babel-traverse/src/path/lib/virtual-types.ts
+++ b/packages/babel-traverse/src/path/lib/virtual-types.ts
@@ -23,7 +23,14 @@ import {
 import type * as t from "@babel/types";
 const { isCompatTag } = react;
 
-export const ReferencedIdentifier = {
+type NodeTypes = t.Node["type"] | t.Comment["type"] | keyof t.Aliases;
+
+export type Wrapper = {
+  types?: NodeTypes[];
+  checkPath?(path: NodePath): boolean;
+};
+
+export const ReferencedIdentifier: Wrapper = {
   types: ["Identifier", "JSXIdentifier"],
   checkPath(path: NodePath, opts?: any): boolean {
     const { node, parent } = path;
@@ -41,14 +48,14 @@ export const ReferencedIdentifier = {
   },
 };
 
-export const ReferencedMemberExpression = {
+export const ReferencedMemberExpression: Wrapper = {
   types: ["MemberExpression"],
-  checkPath({ node, parent }) {
+  checkPath({ node, parent }: NodePath) {
     return isMemberExpression(node) && isReferenced(node, parent);
   },
 };
 
-export const BindingIdentifier = {
+export const BindingIdentifier: Wrapper = {
   types: ["Identifier"],
   checkPath(path: NodePath): boolean {
     const { node, parent } = path;
@@ -57,7 +64,7 @@ export const BindingIdentifier = {
   },
 };
 
-export const Statement = {
+export const Statement: Wrapper = {
   types: ["Statement"],
   checkPath({ node, parent }: NodePath): boolean {
     if (isStatement(node)) {
@@ -73,7 +80,7 @@ export const Statement = {
   },
 };
 
-export const Expression = {
+export const Expression: Wrapper = {
   types: ["Expression"],
   checkPath(path: NodePath): boolean {
     if (path.isIdentifier()) {
@@ -84,52 +91,52 @@ export const Expression = {
   },
 };
 
-export const Scope = {
+export const Scope: Wrapper = {
   // When pattern is inside the function params, it is a scope
   types: ["Scopable", "Pattern"],
-  checkPath(path) {
+  checkPath(path: NodePath) {
     return isScope(path.node, path.parent);
   },
 };
 
-export const Referenced = {
+export const Referenced: Wrapper = {
   checkPath(path: NodePath): boolean {
     return isReferenced(path.node, path.parent);
   },
 };
 
-export const BlockScoped = {
+export const BlockScoped: Wrapper = {
   checkPath(path: NodePath): boolean {
     return isBlockScoped(path.node);
   },
 };
 
-export const Var = {
+export const Var: Wrapper = {
   types: ["VariableDeclaration"],
   checkPath(path: NodePath): boolean {
     return isVar(path.node);
   },
 };
 
-export const User = {
+export const User: Wrapper = {
   checkPath(path: NodePath): boolean {
     return path.node && !!path.node.loc;
   },
 };
 
-export const Generated = {
+export const Generated: Wrapper = {
   checkPath(path: NodePath): boolean {
     return !path.isUser();
   },
 };
 
-export const Pure = {
+export const Pure: Wrapper = {
   checkPath(path: NodePath, constantsOnly?: boolean): boolean {
     return path.scope.isPure(path.node, constantsOnly);
   },
 };
 
-export const Flow = {
+export const Flow: Wrapper = {
   types: ["Flow", "ImportDeclaration", "ExportDeclaration", "ImportSpecifier"],
   checkPath({ node }: NodePath): boolean {
     if (isFlow(node)) {
@@ -147,29 +154,29 @@ export const Flow = {
 };
 
 // TODO: 7.0 Backwards Compat
-export const RestProperty = {
+export const RestProperty: Wrapper = {
   types: ["RestElement"],
   checkPath(path: NodePath): boolean {
     return path.parentPath && path.parentPath.isObjectPattern();
   },
 };
 
-export const SpreadProperty = {
+export const SpreadProperty: Wrapper = {
   types: ["RestElement"],
   checkPath(path: NodePath): boolean {
     return path.parentPath && path.parentPath.isObjectExpression();
   },
 };
 
-export const ExistentialTypeParam = {
+export const ExistentialTypeParam: Wrapper = {
   types: ["ExistsTypeAnnotation"],
 };
 
-export const NumericLiteralTypeAnnotation = {
+export const NumericLiteralTypeAnnotation: Wrapper = {
   types: ["NumberLiteralTypeAnnotation"],
 };
 
-export const ForAwaitStatement = {
+export const ForAwaitStatement: Wrapper = {
   types: ["ForOfStatement"],
   checkPath({ node }: NodePath<t.ForOfStatement>): boolean {
     return node.await === true;
diff --git a/packages/babel-traverse/src/path/modification.ts b/packages/babel-traverse/src/path/modification.ts
index e3308652a7c6..3b0bc6e5f36e 100644
--- a/packages/babel-traverse/src/path/modification.ts
+++ b/packages/babel-traverse/src/path/modification.ts
@@ -26,7 +26,10 @@ import type Scope from "../scope";
  * Insert the provided nodes before the current one.
  */
 
-export function insertBefore(this: NodePath, nodes_: t.Node | t.Node[]) {
+export function insertBefore(
+  this: NodePath,
+  nodes_: t.Node | t.Node[],
+): NodePath[] {
   this._assertUnremoved();
 
   const nodes = this._verifyNodeList(nodes_);
@@ -57,7 +60,11 @@ export function insertBefore(this: NodePath, nodes_: t.Node | t.Node[]) {
         (node as t.ExpressionStatement).expression != null);
 
     this.replaceWith(blockStatement(shouldInsertCurrentNode ? [node] : []));
-    return this.unshiftContainer("body", nodes);
+    return (this as NodePath<t.BlockStatement>).unshiftContainer(
+      "body",
+      // @ts-ignore Fixme: refine nodes to t.BlockStatement["body"] when this is a BlockStatement path
+      nodes,
+    );
   } else {
     throw new Error(
       "We don't know what to do with this node type. " +
@@ -66,16 +73,20 @@ export function insertBefore(this: NodePath, nodes_: t.Node | t.Node[]) {
   }
 }
 
-export function _containerInsert(this: NodePath, from, nodes) {
+export function _containerInsert<N extends t.Node>(
+  this: NodePath,
+  from: number,
+  nodes: N[],
+): NodePath<N>[] {
   this.updateSiblingKeys(from, nodes.length);
 
-  const paths = [];
+  const paths: NodePath<N>[] = [];
 
   // @ts-expect-error todo(flow->ts): this.container could be a NodePath
   this.container.splice(from, 0, ...nodes);
   for (let i = 0; i < nodes.length; i++) {
     const to = from + i;
-    const path = this.getSibling(to);
+    const path = this.getSibling(to) as NodePath<N>;
     paths.push(path);
 
     if (this.context && this.context.queue) {
@@ -97,18 +108,23 @@ export function _containerInsert(this: NodePath, from, nodes) {
   return paths;
 }
 
-export function _containerInsertBefore(this: NodePath, nodes) {
-  return this._containerInsert(this.key, nodes);
+export function _containerInsertBefore<N extends t.Node>(
+  this: NodePath,
+  nodes: N[],
+) {
+  return this._containerInsert(this.key as number, nodes);
 }
 
-export function _containerInsertAfter(this: NodePath, nodes) {
-  // @ts-expect-error todo(flow->ts): this.key could be a string
-  return this._containerInsert(this.key + 1, nodes);
+export function _containerInsertAfter<N extends t.Node>(
+  this: NodePath,
+  nodes: N[],
+) {
+  return this._containerInsert((this.key as number) + 1, nodes);
 }
 
-const last = arr => arr[arr.length - 1];
+const last = <T>(arr: T[]) => arr[arr.length - 1];
 
-function isHiddenInSequenceExpression(path: NodePath) {
+function isHiddenInSequenceExpression(path: NodePath): boolean {
   return (
     isSequenceExpression(path.parent) &&
     (last(path.parent.expressions) !== path.node ||
@@ -185,7 +201,7 @@ export function insertAfter(
         assertExpression(node);
 
         this.replaceWith(callExpression(arrowFunctionExpression([], node), []));
-        (this.get("callee.body") as NodePath).insertAfter(nodes);
+        (this.get("callee.body") as NodePath<t.Expression>).insertAfter(nodes);
         return [this];
       }
 
@@ -233,6 +249,7 @@ export function insertAfter(
         (node as t.ExpressionStatement).expression != null);
 
     this.replaceWith(blockStatement(shouldInsertCurrentNode ? [node] : []));
+    // @ts-ignore Fixme: refine nodes to t.BlockStatement["body"] when this is a BlockStatement path
     return this.pushContainer("body", nodes);
   } else {
     throw new Error(
@@ -261,10 +278,10 @@ export function updateSiblingKeys(
   }
 }
 
-export function _verifyNodeList(
+export function _verifyNodeList<N extends t.Node>(
   this: NodePath,
-  nodes: t.Node | t.Node[],
-): t.Node[] {
+  nodes: N | N[],
+): N[] {
   if (!nodes) {
     return [];
   }
@@ -298,11 +315,17 @@ export function _verifyNodeList(
   return nodes;
 }
 
-export function unshiftContainer<Nodes extends t.Node | t.Node[]>(
-  this: NodePath,
-  listKey: string,
-  nodes: Nodes,
-): NodePath[] {
+export function unshiftContainer<N extends t.Node, K extends keyof N & string>(
+  this: NodePath<N>,
+  listKey: K,
+  nodes: N[K] extends (infer E)[]
+    ? E | E[]
+    : // todo: refine to t.Node[]
+      //  ? E extends t.Node
+      //    ? E | E[]
+      //    : never
+      never,
+) {
   // todo: NodePaths<Nodes>
   this._assertUnremoved();
 
@@ -314,22 +337,34 @@ export function unshiftContainer<Nodes extends t.Node | t.Node[]>(
   const path = NodePath.get({
     parentPath: this,
     parent: this.node,
-    container: this.node[listKey],
+    container: this.node[listKey] as unknown as t.Node | t.Node[],
     listKey,
     key: 0,
   }).setContext(this.context);
 
-  return path._containerInsertBefore(nodes);
+  return path._containerInsertBefore(
+    // @ts-expect-error typings needed to narrow down nodes as t.Node[]
+    nodes,
+  );
 }
 
-export function pushContainer(
-  this: NodePath,
-  listKey: string,
-  nodes: t.Node | t.Node[],
+export function pushContainer<N extends t.Node, K extends keyof N & string>(
+  this: NodePath<N>,
+  listKey: K,
+  nodes: N[K] extends (infer E)[]
+    ? E | E[]
+    : // todo: refine to t.Node[]
+      //  ? E extends t.Node
+      //    ? E | E[]
+      //    : never
+      never,
 ) {
   this._assertUnremoved();
 
-  const verifiedNodes = this._verifyNodeList(nodes);
+  const verifiedNodes = this._verifyNodeList(
+    // @ts-expect-error refine typings
+    nodes,
+  );
 
   // get an invisible path that represents the last node + 1 and replace it with our
   // nodes, effectively inlining it
@@ -338,8 +373,9 @@ export function pushContainer(
   const path = NodePath.get({
     parentPath: this,
     parent: this.node,
-    container: container,
+    container: container as unknown as t.Node | t.Node[],
     listKey,
+    // @ts-expect-error TS cannot infer that container is t.Node[]
     key: container.length,
   }).setContext(this.context);
 
diff --git a/packages/babel-traverse/src/path/replacement.ts b/packages/babel-traverse/src/path/replacement.ts
index bf7f388d2d9c..5c851f8183d5 100644
--- a/packages/babel-traverse/src/path/replacement.ts
+++ b/packages/babel-traverse/src/path/replacement.ts
@@ -40,7 +40,7 @@ import hoistVariables from "@babel/helper-hoist-variables";
 
 export function replaceWithMultiple(
   this: NodePath,
-  nodes: t.Node[],
+  nodes: t.Node | t.Node[],
 ): NodePath[] {
   this.resync();
 
@@ -48,7 +48,9 @@ export function replaceWithMultiple(
   inheritLeadingComments(nodes[0], this.node);
   inheritTrailingComments(nodes[nodes.length - 1], this.node);
   pathCache.get(this.parent)?.delete(this.node);
-  this.node = this.container[this.key] = null;
+  this.node =
+    // @ts-expect-error this.key must present in this.container
+    this.container[this.key] = null;
   const paths = this.insertAfter(nodes);
 
   if (this.node) {
@@ -67,12 +69,13 @@ export function replaceWithMultiple(
  * easier to use, your transforms will be extremely brittle.
  */
 
-export function replaceWithSourceString(this: NodePath, replacement) {
+export function replaceWithSourceString(this: NodePath, replacement: string) {
   this.resync();
+  let ast: t.File;
 
   try {
     replacement = `(${replacement})`;
-    replacement = parse(replacement);
+    ast = parse(replacement);
   } catch (err) {
     const loc = err.loc;
     if (loc) {
@@ -89,25 +92,30 @@ export function replaceWithSourceString(this: NodePath, replacement) {
     throw err;
   }
 
-  replacement = replacement.program.body[0].expression;
-  traverse.removeProperties(replacement);
-  return this.replaceWith(replacement);
+  const expressionAST = (ast.program.body[0] as t.ExpressionStatement)
+    .expression;
+  traverse.removeProperties(expressionAST);
+  return this.replaceWith(expressionAST);
 }
 
 /**
  * Replace the current node with another.
  */
 
-export function replaceWith(this: NodePath, replacement: t.Node | NodePath) {
+export function replaceWith<R extends t.Node>(
+  this: NodePath,
+  replacementPath: R | NodePath<R>,
+): [NodePath<R>] {
   this.resync();
 
   if (this.removed) {
     throw new Error("You can't replace this node, we've already removed it");
   }
 
-  if (replacement instanceof NodePath) {
-    replacement = replacement.node;
-  }
+  let replacement: t.Node =
+    replacementPath instanceof NodePath
+      ? replacementPath.node
+      : replacementPath;
 
   if (!replacement) {
     throw new Error(
@@ -116,7 +124,7 @@ export function replaceWith(this: NodePath, replacement: t.Node | NodePath) {
   }
 
   if (this.node === replacement) {
-    return [this];
+    return [this as NodePath<R>];
   }
 
   if (this.isProgram() && !isProgram(replacement)) {
@@ -157,7 +165,9 @@ export function replaceWith(this: NodePath, replacement: t.Node | NodePath) {
       !this.canSwapBetweenExpressionAndStatement(replacement)
     ) {
       // replacing an expression with a statement so let's explode it
-      return this.replaceExpressionWithStatements([replacement]);
+      return this.replaceExpressionWithStatements([replacement]) as [
+        NodePath<R>,
+      ];
     }
   }
 
@@ -177,14 +187,16 @@ export function replaceWith(this: NodePath, replacement: t.Node | NodePath) {
   // requeue for visiting
   this.requeue();
 
-  return [nodePath ? this.get(nodePath) : this];
+  return [
+    nodePath ? (this.get(nodePath) as NodePath<R>) : (this as NodePath<R>),
+  ];
 }
 
 /**
  * Description
  */
 
-export function _replaceWith(this: NodePath, node) {
+export function _replaceWith(this: NodePath, node: t.Node) {
   if (!this.container) {
     throw new ReferenceError("Container is falsy");
   }
@@ -199,7 +211,9 @@ export function _replaceWith(this: NodePath, node) {
   this.debug(`Replace with ${node?.type}`);
   pathCache.get(this.parent)?.set(node, this).delete(this.node);
 
-  this.node = this.container[this.key] = node;
+  this.node =
+    // @ts-expect-error this.key must present in this.container
+    this.container[this.key] = node;
 }
 
 /**
@@ -229,7 +243,9 @@ export function replaceExpressionWithStatements(
   this.replaceWith(callExpression(container, []));
   // replaceWith changes the type of "this", but it isn't trackable by TS
   type ThisType = NodePath<
-    t.CallExpression & { callee: t.ArrowFunctionExpression }
+    t.CallExpression & {
+      callee: t.ArrowFunctionExpression & { body: t.BlockStatement };
+    }
   >;
 
   // hoist variable declaration in do block
diff --git a/packages/babel-traverse/src/scope/index.ts b/packages/babel-traverse/src/scope/index.ts
index 06504a5df426..f2e6cff3a3b9 100644
--- a/packages/babel-traverse/src/scope/index.ts
+++ b/packages/babel-traverse/src/scope/index.ts
@@ -26,9 +26,11 @@ import {
   isMethod,
   isModuleDeclaration,
   isModuleSpecifier,
+  isNullLiteral,
   isObjectExpression,
   isProperty,
   isPureish,
+  isRegExpLiteral,
   isSuper,
   isTaggedTemplateExpression,
   isTemplateLiteral,
@@ -53,8 +55,9 @@ import type * as t from "@babel/types";
 import { scope as scopeCache } from "../cache";
 import type { Visitor } from "../types";
 
+type NodePart = string | number | boolean;
 // Recursively gathers the identifying names of a node.
-function gatherNodeParts(node: t.Node, parts: any[]) {
+function gatherNodeParts(node: t.Node, parts: NodePart[]) {
   switch (node?.type) {
     default:
       if (isModuleDeclaration(node)) {
@@ -89,14 +92,12 @@ function gatherNodeParts(node: t.Node, parts: any[]) {
         //    allowing only nodes with `.local`?
         // @ts-expect-error todo(flow->ts)
         gatherNodeParts(node.local, parts);
-      } else if (isLiteral(node)) {
-        // todo(flow->ts): should condition be stricter to ensure value is there
-        //   ```
-        //   !t.isNullLiteral(node) &&
-        //   !t.isRegExpLiteral(node) &&
-        //   !isTemplateLiteral(node)
-        //   ```
-        // @ts-expect-error todo(flow->ts)
+      } else if (
+        isLiteral(node) &&
+        !isNullLiteral(node) &&
+        !isRegExpLiteral(node) &&
+        !isTemplateLiteral(node)
+      ) {
         parts.push(node.value);
       }
       break;
@@ -204,7 +205,7 @@ function gatherNodeParts(node: t.Node, parts: any[]) {
       break;
 
     case "JSXOpeningElement":
-      parts.push(node.name);
+      gatherNodeParts(node.name, parts);
       break;
 
     case "JSXFragment":
@@ -353,6 +354,7 @@ const collectorVisitor: Visitor<CollectVisitorState> = {
     if (
       path.isFunctionExpression() &&
       path.has("id") &&
+      // @ts-ignore Fixme: document symbol ast properties
       !path.get("id").node[NOT_LOCAL_BINDING]
     ) {
       path.scope.registerBinding("local", path.get("id"), path);
@@ -360,7 +362,11 @@ const collectorVisitor: Visitor<CollectVisitorState> = {
   },
 
   ClassExpression(path) {
-    if (path.has("id") && !path.get("id").node[NOT_LOCAL_BINDING]) {
+    if (
+      path.has("id") &&
+      // @ts-ignore Fixme: document symbol ast properties
+      !path.get("id").node[NOT_LOCAL_BINDING]
+    ) {
       path.scope.registerBinding("local", path);
     }
   },
@@ -374,23 +380,23 @@ export default class Scope {
   uid;
 
   path: NodePath;
-  block: t.Node;
+  block: t.Pattern | t.Scopable;
 
   labels;
   inited;
 
   bindings: { [name: string]: Binding };
-  references: object;
-  globals: object;
-  uids: object;
-  data: object;
+  references: { [name: string]: true };
+  globals: { [name: string]: t.Identifier | t.JSXIdentifier };
+  uids: { [name: string]: boolean };
+  data: { [key: string | symbol]: unknown };
   crawling: boolean;
 
   /**
    * This searches the current "scope" and collects all references/bindings
    * within.
    */
-  constructor(path: NodePath) {
+  constructor(path: NodePath<t.Pattern | t.Scopable>) {
     const { node } = path;
     const cached = scopeCache.get(node);
     // Sometimes, a scopable path is placed higher in the AST tree.
@@ -452,7 +458,7 @@ export default class Scope {
   /**
    * Traverse node with current scope and path.
    */
-  traverse(node: any, opts: any, state?) {
+  traverse<S>(node: any, opts: any, state?: S) {
     traverse(node, opts, this, state, this.path);
   }
 
@@ -506,14 +512,14 @@ export default class Scope {
    * Generate an `_id1`.
    */
 
-  _generateUid(name, i) {
+  _generateUid(name: string, i: number) {
     let id = name;
     if (i > 1) id += i;
     return `_${id}`;
   }
 
   generateUidBasedOnNode(node: t.Node, defaultName?: string) {
-    const parts = [];
+    const parts: NodePart[] = [];
     gatherNodeParts(node, parts);
 
     let id = parts.join("$");
@@ -605,7 +611,7 @@ export default class Scope {
     }
   }
 
-  rename(oldName: string, newName?: string, block?: t.Node) {
+  rename(oldName: string, newName?: string, block?: t.Pattern | t.Scopable) {
     const binding = this.getBinding(oldName);
     if (binding) {
       newName = newName || this.generateUidIdentifier(oldName).name;
@@ -613,7 +619,13 @@ export default class Scope {
     }
   }
 
-  _renameFromMap(map, oldName, newName, value) {
+  /** @deprecated Not used in our codebase */
+  _renameFromMap(
+    map: Record<string | symbol, unknown>,
+    oldName: string | symbol,
+    newName: string | symbol,
+    value: unknown,
+  ) {
     if (map[oldName]) {
       map[newName] = value;
       map[oldName] = null;
@@ -798,8 +810,7 @@ export default class Scope {
     }
   }
 
-  // todo: flow->ts maybe add more specific type
-  addGlobal(node: Extract<t.Node, { name: string }>) {
+  addGlobal(node: t.Identifier | t.JSXIdentifier) {
     this.globals[node.name] = node;
   }
 
@@ -827,7 +838,7 @@ export default class Scope {
     return !!this.getProgramParent().references[name];
   }
 
-  isPure(node: t.Node, constantsOnly?: boolean) {
+  isPure(node: t.Node, constantsOnly?: boolean): boolean {
     if (isIdentifier(node)) {
       const binding = this.getBinding(node.name);
       if (!binding) return false;
@@ -1030,6 +1041,7 @@ export default class Scope {
     }
 
     if (path.isLoop() || path.isCatchClause() || path.isFunction()) {
+      // @ts-expect-error TS can not infer NodePath<Loop> | NodePath<CatchClause> as NodePath<Loop | CatchClause>
       path.ensureBlock();
       // @ts-expect-error todo(flow->ts): improve types
       path = path.get("body");
@@ -1047,7 +1059,10 @@ export default class Scope {
       // @ts-expect-error todo(flow->ts): avoid modifying nodes
       declar._blockHoist = blockHoist;
 
-      [declarPath] = path.unshiftContainer("body", [declar]);
+      [declarPath] = (path as NodePath<t.BlockStatement>).unshiftContainer(
+        "body",
+        [declar],
+      );
       if (!unique) path.setData(dataKey, declarPath);
     }
 
@@ -1219,7 +1234,7 @@ export default class Scope {
     return !!this.getOwnBinding(name);
   }
 
-  hasBinding(name: string, noGlobals?) {
+  hasBinding(name: string, noGlobals?: boolean) {
     if (!name) return false;
     if (this.hasOwnBinding(name)) return true;
     if (this.parentHasBinding(name, noGlobals)) return true;
@@ -1229,7 +1244,7 @@ export default class Scope {
     return false;
   }
 
-  parentHasBinding(name: string, noGlobals?) {
+  parentHasBinding(name: string, noGlobals?: boolean) {
     return this.parent?.hasBinding(name, noGlobals);
   }
 
diff --git a/packages/babel-traverse/src/scope/lib/renamer.ts b/packages/babel-traverse/src/scope/lib/renamer.ts
index a2aefffab79b..d81e71b419b6 100644
--- a/packages/babel-traverse/src/scope/lib/renamer.ts
+++ b/packages/babel-traverse/src/scope/lib/renamer.ts
@@ -1,13 +1,7 @@
 import Binding from "../binding";
 import splitExportDeclaration from "@babel/helper-split-export-declaration";
-import {
-  assignmentExpression,
-  identifier,
-  toExpression,
-  variableDeclaration,
-  variableDeclarator,
-} from "@babel/types";
-import type { Visitor } from "../../types";
+import * as t from "@babel/types";
+import type { NodePath, Visitor } from "../..";
 import { requeueComputedKeyAndDecorators } from "@babel/helper-environment-visitor";
 
 const renameVisitor: Visitor<Renamer> = {
@@ -31,7 +25,10 @@ const renameVisitor: Visitor<Renamer> = {
     }
   },
 
-  "AssignmentExpression|Declaration|VariableDeclarator"(path, state) {
+  "AssignmentExpression|Declaration|VariableDeclarator"(
+    path: NodePath<t.AssignmentPattern | t.Declaration | t.VariableDeclarator>,
+    state,
+  ) {
     if (path.isVariableDeclaration()) return;
     const ids = path.getOuterBindingIdentifiers();
 
@@ -52,63 +49,69 @@ export default class Renamer {
   declare newName: string;
   declare binding: Binding;
 
-  maybeConvertFromExportDeclaration(parentDeclar) {
+  maybeConvertFromExportDeclaration(parentDeclar: NodePath) {
     const maybeExportDeclar = parentDeclar.parentPath;
 
     if (!maybeExportDeclar.isExportDeclaration()) {
       return;
     }
 
-    if (
-      maybeExportDeclar.isExportDefaultDeclaration() &&
-      !maybeExportDeclar.get("declaration").node.id
-    ) {
+    if (maybeExportDeclar.isExportDefaultDeclaration()) {
+      const { declaration } = maybeExportDeclar.node;
+      if (t.isDeclaration(declaration) && !declaration.id) {
+        return;
+      }
+    }
+
+    if (maybeExportDeclar.isExportAllDeclaration()) {
       return;
     }
 
-    splitExportDeclaration(maybeExportDeclar);
+    splitExportDeclaration(
+      maybeExportDeclar as NodePath<
+        Exclude<t.ExportDeclaration, t.ExportAllDeclaration>
+      >,
+    );
   }
 
-  maybeConvertFromClassFunctionDeclaration(path) {
-    return; // TODO
+  maybeConvertFromClassFunctionDeclaration(path: NodePath) {
+    return path; // TODO
 
-    // retain the `name` of a class/function declaration
+    // // retain the `name` of a class/function declaration
 
-    // eslint-disable-next-line no-unreachable
-    if (!path.isFunctionDeclaration() && !path.isClassDeclaration()) return;
-    if (this.binding.kind !== "hoisted") return;
+    // if (!path.isFunctionDeclaration() && !path.isClassDeclaration()) return;
+    // if (this.binding.kind !== "hoisted") return;
 
-    path.node.id = identifier(this.oldName);
-    path.node._blockHoist = 3;
+    // path.node.id = identifier(this.oldName);
+    // path.node._blockHoist = 3;
 
-    path.replaceWith(
-      variableDeclaration("let", [
-        variableDeclarator(identifier(this.newName), toExpression(path.node)),
-      ]),
-    );
+    // path.replaceWith(
+    //   variableDeclaration("let", [
+    //     variableDeclarator(identifier(this.newName), toExpression(path.node)),
+    //   ]),
+    // );
   }
 
-  maybeConvertFromClassFunctionExpression(path) {
-    return; // TODO
+  maybeConvertFromClassFunctionExpression(path: NodePath) {
+    return path; // TODO
 
-    // retain the `name` of a class/function expression
+    // // retain the `name` of a class/function expression
 
-    // eslint-disable-next-line no-unreachable
-    if (!path.isFunctionExpression() && !path.isClassExpression()) return;
-    if (this.binding.kind !== "local") return;
+    // if (!path.isFunctionExpression() && !path.isClassExpression()) return;
+    // if (this.binding.kind !== "local") return;
 
-    path.node.id = identifier(this.oldName);
+    // path.node.id = identifier(this.oldName);
 
-    this.binding.scope.parent.push({
-      id: identifier(this.newName),
-    });
+    // this.binding.scope.parent.push({
+    //   id: identifier(this.newName),
+    // });
 
-    path.replaceWith(
-      assignmentExpression("=", identifier(this.newName), path.node),
-    );
+    // path.replaceWith(
+    //   assignmentExpression("=", identifier(this.newName), path.node),
+    // );
   }
 
-  rename(block?) {
+  rename(block?: t.Pattern | t.Scopable) {
     const { binding, oldName, newName } = this;
     const { scope, path } = binding;
 
@@ -144,8 +147,8 @@ export default class Renamer {
     }
 
     if (parentDeclar) {
-      this.maybeConvertFromClassFunctionDeclaration(parentDeclar);
-      this.maybeConvertFromClassFunctionExpression(parentDeclar);
+      this.maybeConvertFromClassFunctionDeclaration(path);
+      this.maybeConvertFromClassFunctionExpression(path);
     }
   }
 }
diff --git a/packages/babel-traverse/src/traverse-node.ts b/packages/babel-traverse/src/traverse-node.ts
index 4bfd802ce75f..958664c77326 100644
--- a/packages/babel-traverse/src/traverse-node.ts
+++ b/packages/babel-traverse/src/traverse-node.ts
@@ -12,7 +12,7 @@ import { VISITOR_KEYS } from "@babel/types";
  * @param {scope} scope A traversal scope used to create a new traversal context. When opts.noScope is true, scope should not be provided
  * @param {any} state A user data storage provided as the second callback argument for traversal visitors
  * @param {NodePath} path A NodePath of given node
- * @param {string[]} skipKeys A list of key names that should be skipped during traversal. The skipKeys are applied to every descendants
+ * @param {Record<string, boolean>} skipKeys A map from key names to whether that should be skipped during traversal. The skipKeys are applied to every descendants
  * @returns {boolean} Whether the traversal stops early
 
  * @note This function does not visit the given `node`.
@@ -23,7 +23,7 @@ export function traverseNode(
   scope?: Scope,
   state?: any,
   path?: NodePath,
-  skipKeys?: string[],
+  skipKeys?: Record<string, boolean>,
 ): boolean {
   const keys = VISITOR_KEYS[node.type];
   if (!keys) return false;
diff --git a/packages/babel-traverse/src/types.ts b/packages/babel-traverse/src/types.ts
index 527de9f333ad..c0fadb16f8d4 100644
--- a/packages/babel-traverse/src/types.ts
+++ b/packages/babel-traverse/src/types.ts
@@ -8,10 +8,18 @@ export type Visitor<S = {}> = VisitNodeObject<S, t.Node> & {
   [K in keyof t.Aliases]?: VisitNode<S, t.Aliases[K]>;
 } & {
   [K in keyof VirtualTypeAliases]?: VisitNode<S, VirtualTypeAliases[K]>;
+} & {
+  [K in keyof InternalVisitorFlags]?: InternalVisitorFlags[K];
 } & {
   [k: string]: VisitNode<S, t.Node>;
 };
 
+/** @internal */
+type InternalVisitorFlags = {
+  _exploded?: boolean;
+  _verified?: boolean;
+};
+
 export type VisitNode<S, P extends t.Node> =
   | VisitNodeFunction<S, P>
   | VisitNodeObject<S, P>;
diff --git a/packages/babel-traverse/src/visitors.ts b/packages/babel-traverse/src/visitors.ts
index de2fe704b199..fe2504bdb766 100644
--- a/packages/babel-traverse/src/visitors.ts
+++ b/packages/babel-traverse/src/visitors.ts
@@ -1,6 +1,7 @@
 import * as virtualTypes from "./path/lib/virtual-types";
+import type { Wrapper } from "./path/lib/virtual-types";
 import { DEPRECATED_KEYS, FLIPPED_ALIAS_KEYS, TYPES } from "@babel/types";
-import type { Visitor } from "./types";
+import type { NodePath, Visitor } from "./index";
 
 /**
  * explode() will take a visitor object with all of the various shorthands
@@ -18,7 +19,7 @@ import type { Visitor } from "./types";
  * * `enter` and `exit` functions are wrapped in arrays, to ease merging of
  *   visitors
  */
-export function explode(visitor) {
+export function explode(visitor: Visitor) {
   if (visitor._exploded) return visitor;
   visitor._exploded = true;
 
@@ -54,12 +55,14 @@ export function explode(visitor) {
   for (const nodeType of Object.keys(visitor)) {
     if (shouldIgnoreKey(nodeType)) continue;
 
+    // @ts-expect-error Fixme: nodeType could index virtualTypes
     const wrapper = virtualTypes[nodeType];
     if (!wrapper) continue;
 
     // wrap all the functions
     const fns = visitor[nodeType];
     for (const type of Object.keys(fns)) {
+      // @ts-expect-error manipulating visitors
       fns[type] = wrapCheck(wrapper, fns[type]);
     }
 
@@ -114,13 +117,16 @@ export function explode(visitor) {
   for (const nodeType of Object.keys(visitor)) {
     if (shouldIgnoreKey(nodeType)) continue;
 
-    ensureCallbackArrays(visitor[nodeType]);
+    ensureCallbackArrays(
+      // @ts-expect-error nodeType must present in visitor after previous validations
+      visitor[nodeType],
+    );
   }
 
   return visitor;
 }
 
-export function verify(visitor) {
+export function verify(visitor: Visitor) {
   if (visitor._verified) return;
 
   if (typeof visitor === "function") {
@@ -165,7 +171,10 @@ export function verify(visitor) {
   visitor._verified = true;
 }
 
-function validateVisitorMethods(path, val) {
+function validateVisitorMethods(
+  path: string,
+  val: any,
+): asserts val is Function | Function[] {
   const fns = [].concat(val);
   for (const fn of fns) {
     if (typeof fn !== "function") {
@@ -187,7 +196,7 @@ export function merge(
   states: any[] = [],
   wrapper?: Function | null,
 ) {
-  const rootVisitor = {};
+  const rootVisitor: Visitor = {};
 
   for (let i = 0; i < visitors.length; i++) {
     const visitor = visitors[i];
@@ -211,8 +220,12 @@ export function merge(
   return rootVisitor;
 }
 
-function wrapWithStateOrWrapper(oldVisitor, state, wrapper?: Function | null) {
-  const newVisitor = {};
+function wrapWithStateOrWrapper<State>(
+  oldVisitor: Visitor<State>,
+  state: State,
+  wrapper?: Function | null,
+) {
+  const newVisitor: Visitor = {};
 
   for (const key of Object.keys(oldVisitor)) {
     let fns = oldVisitor[key];
@@ -220,16 +233,18 @@ function wrapWithStateOrWrapper(oldVisitor, state, wrapper?: Function | null) {
     // not an enter/exit array of callbacks
     if (!Array.isArray(fns)) continue;
 
+    // @ts-ignore manipulating visitors
     fns = fns.map(function (fn) {
       let newFn = fn;
 
       if (state) {
-        newFn = function (path) {
+        newFn = function (path: NodePath) {
           return fn.call(state, path, state);
         };
       }
 
       if (wrapper) {
+        // @ts-ignore Fixme: document state.key
         newFn = wrapper(state.key, key, newFn);
       }
 
@@ -247,7 +262,7 @@ function wrapWithStateOrWrapper(oldVisitor, state, wrapper?: Function | null) {
   return newVisitor;
 }
 
-function ensureEntranceObjects(obj) {
+function ensureEntranceObjects(obj: Visitor) {
   for (const key of Object.keys(obj)) {
     if (shouldIgnoreKey(key)) continue;
 
@@ -258,13 +273,15 @@ function ensureEntranceObjects(obj) {
   }
 }
 
-function ensureCallbackArrays(obj) {
+function ensureCallbackArrays(obj: Visitor) {
+  // @ts-ignore normalizing enter property
   if (obj.enter && !Array.isArray(obj.enter)) obj.enter = [obj.enter];
+  // @ts-ignore normalizing exit property
   if (obj.exit && !Array.isArray(obj.exit)) obj.exit = [obj.exit];
 }
 
-function wrapCheck(wrapper, fn) {
-  const newFn = function (this: unknown, path) {
+function wrapCheck(wrapper: Wrapper, fn: Function) {
+  const newFn = function (this: unknown, path: NodePath) {
     if (wrapper.checkPath(path)) {
       return fn.apply(this, arguments);
     }
@@ -273,7 +290,7 @@ function wrapCheck(wrapper, fn) {
   return newFn;
 }
 
-function shouldIgnoreKey(key) {
+function shouldIgnoreKey(key: string) {
   // internal/hidden key
   if (key[0] === "_") return true;
 
@@ -294,7 +311,7 @@ function shouldIgnoreKey(key) {
   return false;
 }
 
-function mergePair(dest, src) {
+function mergePair(dest: any, src: any) {
   for (const key of Object.keys(src)) {
     dest[key] = [].concat(dest[key] || [], src[key]);
   }
diff --git a/packages/babel-types/package.json b/packages/babel-types/package.json
index 76c3633beef7..a424bbd2f200 100644
--- a/packages/babel-types/package.json
+++ b/packages/babel-types/package.json
@@ -25,7 +25,7 @@
   },
   "dependencies": {
     "@babel/helper-validator-identifier": "workspace:^",
-    "to-fast-properties": "^2.0.0"
+    "to-fast-properties": "condition:BABEL_8_BREAKING ? ^3.0.0 : ^2.0.0"
   },
   "devDependencies": {
     "@babel/generator": "workspace:^",
diff --git a/packages/babel-types/scripts/generators/ast-types.js b/packages/babel-types/scripts/generators/ast-types.js
index 4c08dcd8f6e4..901e3d2d56d3 100644
--- a/packages/babel-types/scripts/generators/ast-types.js
+++ b/packages/babel-types/scripts/generators/ast-types.js
@@ -7,9 +7,11 @@ export default function generateAstTypes() {
 
 interface BaseComment {
   value: string;
-  start: number;
-  end: number;
-  loc: SourceLocation;
+  start?: number;
+  end?: number;
+  loc?: SourceLocation;
+  // generator will skip the comment if ignore is true
+  ignore?: boolean;
   type: "CommentBlock" | "CommentLine";
 }
 
@@ -37,9 +39,9 @@ export interface SourceLocation {
 
 interface BaseNode {
   type: Node["type"];
-  leadingComments?: ReadonlyArray<Comment> | null;
-  innerComments?: ReadonlyArray<Comment> | null;
-  trailingComments?: ReadonlyArray<Comment> | null;
+  leadingComments?: Comment[] | null;
+  innerComments?: Comment[] | null;
+  trailingComments?: Comment[] | null;
   start?: number | null;
   end?: number | null;
   loc?: SourceLocation | null;
diff --git a/packages/babel-types/src/ast-types/generated/index.ts b/packages/babel-types/src/ast-types/generated/index.ts
index a13ee342a030..5203e07424b6 100644
--- a/packages/babel-types/src/ast-types/generated/index.ts
+++ b/packages/babel-types/src/ast-types/generated/index.ts
@@ -3,9 +3,11 @@
 
 interface BaseComment {
   value: string;
-  start: number;
-  end: number;
-  loc: SourceLocation;
+  start?: number;
+  end?: number;
+  loc?: SourceLocation;
+  // generator will skip the comment if ignore is true
+  ignore?: boolean;
   type: "CommentBlock" | "CommentLine";
 }
 
@@ -33,9 +35,9 @@ export interface SourceLocation {
 
 interface BaseNode {
   type: Node["type"];
-  leadingComments?: ReadonlyArray<Comment> | null;
-  innerComments?: ReadonlyArray<Comment> | null;
-  trailingComments?: ReadonlyArray<Comment> | null;
+  leadingComments?: Comment[] | null;
+  innerComments?: Comment[] | null;
+  trailingComments?: Comment[] | null;
   start?: number | null;
   end?: number | null;
   loc?: SourceLocation | null;
@@ -1909,8 +1911,8 @@ export interface TSMappedType extends BaseNode {
   typeParameter: TSTypeParameter;
   typeAnnotation?: TSType | null;
   nameType?: TSType | null;
-  optional?: boolean | null;
-  readonly?: boolean | null;
+  optional?: true | false | "+" | "-" | null;
+  readonly?: true | false | "+" | "-" | null;
 }
 
 export interface TSLiteralType extends BaseNode {
diff --git a/packages/babel-types/src/builders/validateNode.ts b/packages/babel-types/src/builders/validateNode.ts
index aa6bbd0889b0..a3518383030f 100644
--- a/packages/babel-types/src/builders/validateNode.ts
+++ b/packages/babel-types/src/builders/validateNode.ts
@@ -4,7 +4,7 @@ import { BUILDER_KEYS } from "..";
 
 export default function validateNode<N extends t.Node>(node: N) {
   // todo: because keys not in BUILDER_KEYS are not validated - this actually allows invalid nodes in some cases
-  const keys = BUILDER_KEYS[node.type];
+  const keys = BUILDER_KEYS[node.type] as (keyof N & string)[];
   for (const key of keys) {
     validate(node, key, node[key]);
   }
diff --git a/packages/babel-types/src/clone/cloneNode.ts b/packages/babel-types/src/clone/cloneNode.ts
index 2f2ac74e2b56..cae62cc7ab72 100644
--- a/packages/babel-types/src/clone/cloneNode.ts
+++ b/packages/babel-types/src/clone/cloneNode.ts
@@ -4,8 +4,15 @@ import { isFile, isIdentifier } from "../validators/generated";
 
 const has = Function.call.bind(Object.prototype.hasOwnProperty);
 
+type CommentCache = Map<t.Comment, t.Comment>;
+
 // This function will never be called for comments, only for real nodes.
-function cloneIfNode(obj, deep, withoutLoc, commentsCache) {
+function cloneIfNode(
+  obj: t.Node | undefined | null,
+  deep: boolean,
+  withoutLoc: boolean,
+  commentsCache: CommentCache,
+) {
   if (obj && typeof obj.type === "string") {
     return cloneNodeInternal(obj, deep, withoutLoc, commentsCache);
   }
@@ -13,7 +20,12 @@ function cloneIfNode(obj, deep, withoutLoc, commentsCache) {
   return obj;
 }
 
-function cloneIfNodeOrArray(obj, deep, withoutLoc, commentsCache) {
+function cloneIfNodeOrArray(
+  obj: t.Node | undefined | null | (t.Node | undefined | null)[],
+  deep: boolean,
+  withoutLoc: boolean,
+  commentsCache: CommentCache,
+) {
   if (Array.isArray(obj)) {
     return obj.map(node => cloneIfNode(node, deep, withoutLoc, commentsCache));
   }
@@ -37,7 +49,7 @@ function cloneNodeInternal<T extends t.Node>(
   node: T,
   deep: boolean = true,
   withoutLoc: boolean = false,
-  commentsCache: Map<t.Comment, t.Comment>,
+  commentsCache: CommentCache,
 ): T {
   if (!node) return node;
 
@@ -77,13 +89,16 @@ function cloneNodeInternal<T extends t.Node>(
                   commentsCache,
                 )
               : cloneIfNodeOrArray(
+                  // @ts-expect-error node[field] has been guarded by has check
                   node[field],
                   true,
                   withoutLoc,
                   commentsCache,
                 );
         } else {
-          newNode[field] = node[field];
+          newNode[field] =
+            // @ts-expect-error node[field] has been guarded by has check
+            node[field];
         }
       }
     }
diff --git a/packages/babel-types/src/comments/addComments.ts b/packages/babel-types/src/comments/addComments.ts
index a01ce1c42b94..5aeb69b2328d 100644
--- a/packages/babel-types/src/comments/addComments.ts
+++ b/packages/babel-types/src/comments/addComments.ts
@@ -6,11 +6,11 @@ import type * as t from "..";
 export default function addComments<T extends t.Node>(
   node: T,
   type: t.CommentTypeShorthand,
-  comments: ReadonlyArray<t.Comment>,
+  comments: Array<t.Comment>,
 ): T {
   if (!comments || !node) return node;
 
-  const key = `${type}Comments`;
+  const key = `${type}Comments` as const;
 
   if (node[key]) {
     if (type === "leading") {
diff --git a/packages/babel-types/src/constants/index.ts b/packages/babel-types/src/constants/index.ts
index e3ece7c5d7f5..9eced88e847f 100644
--- a/packages/babel-types/src/constants/index.ts
+++ b/packages/babel-types/src/constants/index.ts
@@ -5,7 +5,7 @@ export const COMMENT_KEYS = [
   "leadingComments",
   "trailingComments",
   "innerComments",
-];
+] as const;
 
 export const LOGICAL_OPERATORS = ["||", "&&", "??"];
 export const UPDATE_OPERATORS = ["++", "--"];
@@ -62,7 +62,7 @@ export const UNARY_OPERATORS = [
 export const INHERIT_KEYS = {
   optional: ["typeAnnotation", "typeParameters", "returnType"],
   force: ["start", "loc", "end"],
-};
+} as const;
 
 export const BLOCK_SCOPED_SYMBOL = Symbol.for("var used to be block scoped");
 export const NOT_LOCAL_BINDING = Symbol.for(
diff --git a/packages/babel-types/src/converters/Scope.ts b/packages/babel-types/src/converters/Scope.ts
deleted file mode 100644
index 3ea3ef8ae48c..000000000000
--- a/packages/babel-types/src/converters/Scope.ts
+++ /dev/null
@@ -1,8 +0,0 @@
-// NOTE: this actually uses Scope from @babel/traverse, but we can't add a dependency on its types,
-// because this would be cyclic dependency. Declare the structural subset that is required.
-import type * as t from "..";
-
-export type Scope = {
-  push(value: { id: t.LVal; kind: "var"; init?: t.Expression }): void;
-  buildUndefinedNode(): t.Node;
-};
diff --git a/packages/babel-types/src/converters/ensureBlock.ts b/packages/babel-types/src/converters/ensureBlock.ts
index 069e099df7c0..581a15af7638 100644
--- a/packages/babel-types/src/converters/ensureBlock.ts
+++ b/packages/babel-types/src/converters/ensureBlock.ts
@@ -11,5 +11,9 @@ export default function ensureBlock(
   node: t.Node,
   key: string = "body",
 ): t.BlockStatement {
-  return (node[key] = toBlock(node[key], node));
+  // @ts-ignore Fixme: key may not exist in node, consider remove key = "body"
+  const result = toBlock(node[key], node);
+  // @ts-ignore
+  node[key] = result;
+  return result;
 }
diff --git a/packages/babel-types/src/converters/gatherSequenceExpressions.ts b/packages/babel-types/src/converters/gatherSequenceExpressions.ts
index 71ef31ec9d6e..caed9484f014 100644
--- a/packages/babel-types/src/converters/gatherSequenceExpressions.ts
+++ b/packages/babel-types/src/converters/gatherSequenceExpressions.ts
@@ -14,14 +14,19 @@ import {
 } from "../builders/generated";
 import cloneNode from "../clone/cloneNode";
 import type * as t from "..";
-import type { Scope } from "./Scope";
+import type { Scope } from "@babel/traverse";
+
+export type DeclarationInfo = {
+  kind: t.VariableDeclaration["kind"];
+  id: t.Identifier;
+};
 
 export default function gatherSequenceExpressions(
   nodes: ReadonlyArray<t.Node>,
   scope: Scope,
-  declars: Array<any>,
-): t.SequenceExpression {
-  const exprs = [];
+  declars: Array<DeclarationInfo>,
+) {
+  const exprs: t.Expression[] = [];
   let ensureLastUndefined = true;
 
   for (const node of nodes) {
@@ -62,7 +67,6 @@ export default function gatherSequenceExpressions(
         : scope.buildUndefinedNode();
       if (!consequent || !alternate) return; // bailed
 
-      // @ts-expect-error todo(flow->ts) consequent - Argument of type 'Node' is not assignable to parameter of type 'Expression'
       exprs.push(conditionalExpression(node.test, consequent, alternate));
     } else if (isBlockStatement(node)) {
       const body = gatherSequenceExpressions(node.body, scope, declars);
diff --git a/packages/babel-types/src/converters/toBlock.ts b/packages/babel-types/src/converters/toBlock.ts
index 34f2a1a640f2..46acf7178276 100644
--- a/packages/babel-types/src/converters/toBlock.ts
+++ b/packages/babel-types/src/converters/toBlock.ts
@@ -19,7 +19,7 @@ export default function toBlock(
     return node;
   }
 
-  let blockNodes = [];
+  let blockNodes: t.Statement[] = [];
 
   if (isEmptyStatement(node)) {
     blockNodes = [];
diff --git a/packages/babel-types/src/converters/toSequenceExpression.ts b/packages/babel-types/src/converters/toSequenceExpression.ts
index 5d99d4cf24f9..86e076669374 100644
--- a/packages/babel-types/src/converters/toSequenceExpression.ts
+++ b/packages/babel-types/src/converters/toSequenceExpression.ts
@@ -1,6 +1,7 @@
 import gatherSequenceExpressions from "./gatherSequenceExpressions";
 import type * as t from "..";
-import type { Scope } from "./Scope";
+import type { Scope } from "@babel/traverse";
+import type { DeclarationInfo } from "./gatherSequenceExpressions";
 
 /**
  * Turn an array of statement `nodes` into a `SequenceExpression`.
@@ -16,7 +17,7 @@ export default function toSequenceExpression(
 ): t.SequenceExpression | undefined {
   if (!nodes?.length) return;
 
-  const declars = [];
+  const declars: DeclarationInfo[] = [];
   const result = gatherSequenceExpressions(nodes, scope, declars);
   if (!result) return;
 
@@ -24,5 +25,6 @@ export default function toSequenceExpression(
     scope.push(declar);
   }
 
+  // @ts-ignore fixme: gatherSequenceExpressions will return an Expression when there are only one element
   return result;
 }
diff --git a/packages/babel-types/src/converters/toStatement.ts b/packages/babel-types/src/converters/toStatement.ts
index 6537206014fa..9f33510b5dc9 100644
--- a/packages/babel-types/src/converters/toStatement.ts
+++ b/packages/babel-types/src/converters/toStatement.ts
@@ -33,17 +33,17 @@ function toStatement(node: t.Node, ignore?: boolean): t.Statement | false {
 
   if (isClass(node)) {
     mustHaveId = true;
-    newType = "ClassDeclaration";
+    newType = "ClassDeclaration" as const;
   } else if (isFunction(node)) {
     mustHaveId = true;
-    newType = "FunctionDeclaration";
+    newType = "FunctionDeclaration" as const;
   } else if (isAssignmentExpression(node)) {
     return expressionStatement(node);
   }
 
   // @ts-expect-error todo(flow->ts): node.id might be missing
   if (mustHaveId && !node.id) {
-    newType = false;
+    newType = false as false;
   }
 
   if (!newType) {
@@ -54,6 +54,7 @@ function toStatement(node: t.Node, ignore?: boolean): t.Statement | false {
     }
   }
 
+  // @ts-expect-error manipulating node.type
   node.type = newType;
 
   // @ts-expect-error todo(flow->ts) refactor to avoid type unsafe mutations like reassigning node type above
diff --git a/packages/babel-types/src/converters/valueToNode.ts b/packages/babel-types/src/converters/valueToNode.ts
index 6eb52b873e7a..521515ab3bbb 100644
--- a/packages/babel-types/src/converters/valueToNode.ts
+++ b/packages/babel-types/src/converters/valueToNode.ts
@@ -31,15 +31,15 @@ export default valueToNode as {
   (value: unknown): t.Expression;
 };
 
-const objectToString: (value: object) => string = Function.call.bind(
+const objectToString: (value: unknown) => string = Function.call.bind(
   Object.prototype.toString,
 );
 
-function isRegExp(value): value is RegExp {
+function isRegExp(value: unknown): value is RegExp {
   return objectToString(value) === "[object RegExp]";
 }
 
-function isPlainObject(value): value is object {
+function isPlainObject(value: unknown): value is object {
   if (
     typeof value !== "object" ||
     value === null ||
@@ -122,7 +122,15 @@ function valueToNode(value: unknown): t.Expression {
       } else {
         nodeKey = stringLiteral(key);
       }
-      props.push(objectProperty(nodeKey, valueToNode(value[key])));
+      props.push(
+        objectProperty(
+          nodeKey,
+          valueToNode(
+            // @ts-expect-error key must present in value
+            value[key],
+          ),
+        ),
+      );
     }
     return objectExpression(props);
   }
diff --git a/packages/babel-types/src/definitions/core.ts b/packages/babel-types/src/definitions/core.ts
index c5f6114f299e..bdd8fa61a794 100644
--- a/packages/babel-types/src/definitions/core.ts
+++ b/packages/babel-types/src/definitions/core.ts
@@ -1,6 +1,7 @@
 import is from "../validators/is";
 import isValidIdentifier from "../validators/isValidIdentifier";
 import { isKeyword, isReservedWord } from "@babel/helper-validator-identifier";
+import type * as t from "..";
 
 import {
   BINARY_OPERATORS,
@@ -21,6 +22,7 @@ import {
   chain,
   assertOneOf,
   validateOptional,
+  type Validator,
 } from "./utils";
 
 const defineType = defineAliasedType("Standardized");
@@ -52,7 +54,7 @@ defineType("AssignmentExpression", {
         const identifier = assertOneOf(...ASSIGNMENT_OPERATORS);
         const pattern = assertOneOf("=");
 
-        return function (node, key, val) {
+        return function (node: t.AssignmentExpression, key, val) {
           const validator = is("Pattern", node.left) ? pattern : identifier;
           validator(node, key, val);
         };
@@ -91,12 +93,14 @@ defineType("BinaryExpression", {
         const expression = assertNodeType("Expression");
         const inOp = assertNodeType("Expression", "PrivateName");
 
-        const validator = function (node, key, val) {
-          const validator = node.operator === "in" ? inOp : expression;
-          validator(node, key, val);
-        };
-        // todo(ts): can be discriminated union by `operator` property
-        validator.oneOfNodeTypes = ["Expression", "PrivateName"];
+        const validator: Validator = Object.assign(
+          function (node: t.BinaryExpression, key, val) {
+            const validator = node.operator === "in" ? inOp : expression;
+            validator(node, key, val);
+          } as Validator,
+          // todo(ts): can be discriminated union by `operator` property
+          { oneOfNodeTypes: ["Expression", "PrivateName"] },
+        );
         return validator;
       })(),
     },
@@ -377,7 +381,12 @@ export const functionTypeAnnotationCommon = {
   returnType: {
     validate: process.env.BABEL_8_BREAKING
       ? assertNodeType("TypeAnnotation", "TSTypeAnnotation")
-      : assertNodeType("TypeAnnotation", "TSTypeAnnotation", "Noop"),
+      : assertNodeType(
+          "TypeAnnotation",
+          "TSTypeAnnotation",
+          // @ts-ignore Babel 7 AST
+          "Noop",
+        ),
     optional: true,
   },
   typeParameters: {
@@ -386,6 +395,7 @@ export const functionTypeAnnotationCommon = {
       : assertNodeType(
           "TypeParameterDeclaration",
           "TSTypeParameterDeclaration",
+          // @ts-ignore Babel 7 AST
           "Noop",
         ),
     optional: true,
@@ -471,7 +481,12 @@ export const patternLikeCommon = {
   typeAnnotation: {
     validate: process.env.BABEL_8_BREAKING
       ? assertNodeType("TypeAnnotation", "TSTypeAnnotation")
-      : assertNodeType("TypeAnnotation", "TSTypeAnnotation", "Noop"),
+      : assertNodeType(
+          "TypeAnnotation",
+          "TSTypeAnnotation",
+          // @ts-ignore Babel 7 AST
+          "Noop",
+        ),
     optional: true,
   },
   decorators: {
@@ -498,7 +513,7 @@ defineType("Identifier", {
             if (!isValidIdentifier(val, false)) {
               throw new TypeError(`"${val}" is not a valid identifier name`);
             }
-          },
+          } as Validator,
           { type: "string" },
         ),
       ),
@@ -631,7 +646,7 @@ defineType("RegExpLiteral", {
             if (invalid) {
               throw new TypeError(`"${invalid[0]}" is not a valid RegExp flag`);
             }
-          },
+          } as Validator,
           { type: "string" },
         ),
       ),
@@ -675,11 +690,15 @@ defineType("MemberExpression", {
         const normal = assertNodeType("Identifier", "PrivateName");
         const computed = assertNodeType("Expression");
 
-        const validator = function (node, key, val) {
-          const validator = node.computed ? computed : normal;
+        const validator: Validator = function (
+          node: t.MemberExpression,
+          key,
+          val,
+        ) {
+          const validator: Validator = node.computed ? computed : normal;
           validator(node, key, val);
         };
-        // todo(ts): can be discriminated union by `computed` property
+        // @ts-expect-error todo(ts): can be discriminated union by `computed` property
         validator.oneOfNodeTypes = ["Expression", "Identifier", "PrivateName"];
         return validator;
       })(),
@@ -771,11 +790,11 @@ defineType("ObjectMethod", {
         );
         const computed = assertNodeType("Expression");
 
-        const validator = function (node, key, val) {
+        const validator: Validator = function (node: t.ObjectMethod, key, val) {
           const validator = node.computed ? computed : normal;
           validator(node, key, val);
         };
-        // todo(ts): can be discriminated union by `computed` property
+        // @ts-expect-error todo(ts): can be discriminated union by `computed` property
         validator.oneOfNodeTypes = [
           "Expression",
           "Identifier",
@@ -839,20 +858,24 @@ defineType("ObjectProperty", {
         );
         const computed = assertNodeType("Expression");
 
-        const validator = function (node, key, val) {
-          const validator = node.computed ? computed : normal;
-          validator(node, key, val);
-        };
-        // todo(ts): can be discriminated union by `computed` property
-        validator.oneOfNodeTypes = [
-          "Expression",
-          "Identifier",
-          "StringLiteral",
-          "NumericLiteral",
-          "BigIntLiteral",
-          "DecimalLiteral",
-          "PrivateName",
-        ];
+        const validator: Validator = Object.assign(
+          function (node: t.ObjectProperty, key, val) {
+            const validator = node.computed ? computed : normal;
+            validator(node, key, val);
+          } as Validator,
+          {
+            // todo(ts): can be discriminated union by `computed` property
+            oneOfNodeTypes: [
+              "Expression",
+              "Identifier",
+              "StringLiteral",
+              "NumericLiteral",
+              "BigIntLiteral",
+              "DecimalLiteral",
+              "PrivateName",
+            ],
+          },
+        );
         return validator;
       })(),
     },
@@ -865,7 +888,7 @@ defineType("ObjectProperty", {
       validate: chain(
         assertValueType("boolean"),
         Object.assign(
-          function (node, key, val) {
+          function (node: t.ObjectProperty, key, val) {
             if (!process.env.BABEL_TYPES_8_BREAKING) return;
 
             if (val && node.computed) {
@@ -873,10 +896,10 @@ defineType("ObjectProperty", {
                 "Property shorthand of ObjectProperty cannot be true if computed is true",
               );
             }
-          },
+          } as Validator,
           { type: "boolean" },
         ),
-        function (node, key, val) {
+        function (node: t.ObjectProperty, key, val) {
           if (!process.env.BABEL_TYPES_8_BREAKING) return;
 
           if (val && !is("Identifier", node.key)) {
@@ -884,7 +907,7 @@ defineType("ObjectProperty", {
               "Property shorthand of ObjectProperty cannot be true if key is not an Identifier",
             );
           }
-        },
+        } as Validator,
       ),
       default: false,
     },
@@ -943,14 +966,18 @@ defineType("RestElement", {
       optional: true,
     },
   },
-  validate(parent, key) {
+  validate(parent: t.ArrayPattern | t.ObjectPattern, key) {
     if (!process.env.BABEL_TYPES_8_BREAKING) return;
 
     const match = /(\w+)\[(\d+)\]/.exec(key);
     if (!match) throw new Error("Internal Babel error: malformed key.");
 
-    const [, listKey, index] = match;
-    if (parent[listKey].length > index + 1) {
+    const [, listKey, index] = match as unknown as [
+      string,
+      keyof typeof parent,
+      string,
+    ];
+    if ((parent[listKey] as t.Node[]).length > +index + 1) {
       throw new TypeError(`RestElement must be last element of ${listKey}`);
     }
   },
@@ -1044,7 +1071,7 @@ defineType("TryStatement", {
       validate: chain(
         assertNodeType("BlockStatement"),
         Object.assign(
-          function (node) {
+          function (node: t.TryStatement) {
             if (!process.env.BABEL_TYPES_8_BREAKING) return;
 
             // This validator isn't put at the top level because we can run it
@@ -1055,7 +1082,7 @@ defineType("TryStatement", {
                 "TryStatement expects either a handler or finalizer, or both",
               );
             }
-          },
+          } as Validator,
           {
             oneOfNodeTypes: ["BlockStatement"],
           },
@@ -1156,7 +1183,7 @@ defineType("VariableDeclarator", {
         );
         const without = assertNodeType("Identifier");
 
-        return function (node, key, val) {
+        return function (node: t.VariableDeclarator, key, val) {
           const validator = node.init ? normal : without;
           validator(node, key, val);
         };
@@ -1338,6 +1365,7 @@ defineType("ClassExpression", {
         : assertNodeType(
             "TypeParameterDeclaration",
             "TSTypeParameterDeclaration",
+            // @ts-ignore Babel 7 AST
             "Noop",
           ),
       optional: true,
@@ -1395,6 +1423,7 @@ defineType("ClassDeclaration", {
         : assertNodeType(
             "TypeParameterDeclaration",
             "TSTypeParameterDeclaration",
+            // @ts-ignore Babel 7 AST
             "Noop",
           ),
       optional: true,
@@ -1512,7 +1541,7 @@ defineType("ExportNamedDeclaration", {
       validate: chain(
         assertNodeType("Declaration"),
         Object.assign(
-          function (node, key, val) {
+          function (node: t.ExportNamedDeclaration, key, val) {
             if (!process.env.BABEL_TYPES_8_BREAKING) return;
 
             // This validator isn't put at the top level because we can run it
@@ -1523,10 +1552,10 @@ defineType("ExportNamedDeclaration", {
                 "Only declaration or specifiers is allowed on ExportNamedDeclaration",
               );
             }
-          },
+          } as Validator,
           { oneOfNodeTypes: ["Declaration"] },
         ),
-        function (node, key, val) {
+        function (node: t.ExportNamedDeclaration, key, val) {
           if (!process.env.BABEL_TYPES_8_BREAKING) return;
 
           // This validator isn't put at the top level because we can run it
@@ -1560,10 +1589,10 @@ defineType("ExportNamedDeclaration", {
 
             if (!process.env.BABEL_TYPES_8_BREAKING) return sourced;
 
-            return function (node, key, val) {
+            return function (node: t.ExportNamedDeclaration, key, val) {
               const validator = node.source ? sourced : sourceless;
               validator(node, key, val);
-            };
+            } as Validator;
           })(),
         ),
       ),
@@ -1726,7 +1755,7 @@ defineType("MetaProperty", {
       validate: chain(
         assertNodeType("Identifier"),
         Object.assign(
-          function (node, key, val) {
+          function (node: t.MetaProperty, key, val) {
             if (!process.env.BABEL_TYPES_8_BREAKING) return;
 
             let property;
@@ -1744,7 +1773,7 @@ defineType("MetaProperty", {
             if (!is("Identifier", node.property, { name: property })) {
               throw new TypeError("Unrecognised MetaProperty");
             }
-          },
+          } as Validator,
           { oneOfNodeTypes: ["Identifier"] },
         ),
       ),
@@ -1962,7 +1991,7 @@ defineType("TemplateLiteral", {
             "TSType",
           ),
         ),
-        function (node, key, val) {
+        function (node: t.TemplateLiteral, key, val) {
           if (node.quasis.length !== val.length + 1) {
             throw new TypeError(
               `Number of ${
@@ -1972,7 +2001,7 @@ defineType("TemplateLiteral", {
               } quasis but got ${node.quasis.length}`,
             );
           }
-        },
+        } as Validator,
       ),
     },
   },
@@ -1987,7 +2016,7 @@ defineType("YieldExpression", {
       validate: chain(
         assertValueType("boolean"),
         Object.assign(
-          function (node, key, val) {
+          function (node: t.YieldExpression, key, val) {
             if (!process.env.BABEL_TYPES_8_BREAKING) return;
 
             if (val && !node.argument) {
@@ -1995,7 +2024,7 @@ defineType("YieldExpression", {
                 "Property delegate of YieldExpression cannot be true if there is no argument",
               );
             }
-          },
+          } as Validator,
           { type: "boolean" },
         ),
       ),
@@ -2059,12 +2088,14 @@ defineType("OptionalMemberExpression", {
         const normal = assertNodeType("Identifier");
         const computed = assertNodeType("Expression");
 
-        const validator = function (node, key, val) {
-          const validator = node.computed ? computed : normal;
-          validator(node, key, val);
-        };
-        // todo(ts): can be discriminated union by `computed` property
-        validator.oneOfNodeTypes = ["Expression", "Identifier"];
+        const validator: Validator = Object.assign(
+          function (node: t.OptionalMemberExpression, key, val) {
+            const validator = node.computed ? computed : normal;
+            validator(node, key, val);
+          } as Validator,
+          // todo(ts): can be discriminated union by `computed` property
+          { oneOfNodeTypes: ["Expression", "Identifier"] },
+        );
         return validator;
       })(),
     },
@@ -2141,7 +2172,12 @@ defineType("ClassProperty", {
     typeAnnotation: {
       validate: process.env.BABEL_8_BREAKING
         ? assertNodeType("TypeAnnotation", "TSTypeAnnotation")
-        : assertNodeType("TypeAnnotation", "TSTypeAnnotation", "Noop"),
+        : assertNodeType(
+            "TypeAnnotation",
+            "TSTypeAnnotation",
+            // @ts-ignore Babel 7 AST
+            "Noop",
+          ),
       optional: true,
     },
     decorators: {
@@ -2215,7 +2251,12 @@ defineType("ClassAccessorProperty", {
     typeAnnotation: {
       validate: process.env.BABEL_8_BREAKING
         ? assertNodeType("TypeAnnotation", "TSTypeAnnotation")
-        : assertNodeType("TypeAnnotation", "TSTypeAnnotation", "Noop"),
+        : assertNodeType(
+            "TypeAnnotation",
+            "TSTypeAnnotation",
+            // @ts-ignore Babel 7 AST
+            "Noop",
+          ),
       optional: true,
     },
     decorators: {
@@ -2255,7 +2296,12 @@ defineType("ClassPrivateProperty", {
     typeAnnotation: {
       validate: process.env.BABEL_8_BREAKING
         ? assertNodeType("TypeAnnotation", "TSTypeAnnotation")
-        : assertNodeType("TypeAnnotation", "TSTypeAnnotation", "Noop"),
+        : assertNodeType(
+            "TypeAnnotation",
+            "TSTypeAnnotation",
+            // @ts-ignore Babel 7 AST
+            "Noop",
+          ),
       optional: true,
     },
     decorators: {
diff --git a/packages/babel-types/src/definitions/flow.ts b/packages/babel-types/src/definitions/flow.ts
index a51e0c91fd06..d66d9420bfd8 100644
--- a/packages/babel-types/src/definitions/flow.ts
+++ b/packages/babel-types/src/definitions/flow.ts
@@ -13,8 +13,7 @@ import {
 const defineType = defineAliasedType("Flow");
 
 const defineInterfaceishType = (
-  name: string,
-  typeParameterType: string = "TypeParameterDeclaration",
+  name: "DeclareClass" | "DeclareInterface" | "InterfaceDeclaration",
 ) => {
   defineType(name, {
     builder: ["id", "typeParameters", "extends", "body"],
@@ -29,7 +28,7 @@ const defineInterfaceishType = (
     aliases: ["FlowDeclaration", "Statement", "Declaration"],
     fields: {
       id: validateType("Identifier"),
-      typeParameters: validateOptionalType(typeParameterType),
+      typeParameters: validateOptionalType("TypeParameterDeclaration"),
       extends: validateOptional(arrayOfType("InterfaceExtends")),
       mixins: validateOptional(arrayOfType("InterfaceExtends")),
       implements: validateOptional(arrayOfType("ClassImplements")),
diff --git a/packages/babel-types/src/definitions/index.ts b/packages/babel-types/src/definitions/index.ts
index a420122dcf61..bd8d27d62c43 100644
--- a/packages/babel-types/src/definitions/index.ts
+++ b/packages/babel-types/src/definitions/index.ts
@@ -50,3 +50,5 @@ export {
   PLACEHOLDERS_FLIPPED_ALIAS,
   TYPES,
 };
+
+export type { FieldOptions } from "./utils";
diff --git a/packages/babel-types/src/definitions/typescript.ts b/packages/babel-types/src/definitions/typescript.ts
index ef8778b68737..c82ee224a214 100644
--- a/packages/babel-types/src/definitions/typescript.ts
+++ b/packages/babel-types/src/definitions/typescript.ts
@@ -26,13 +26,15 @@ const tSFunctionTypeAnnotationCommon = {
   returnType: {
     validate: process.env.BABEL_8_BREAKING
       ? assertNodeType("TSTypeAnnotation")
-      : assertNodeType("TSTypeAnnotation", "Noop"),
+      : // @ts-ignore Babel 7 AST
+        assertNodeType("TSTypeAnnotation", "Noop"),
     optional: true,
   },
   typeParameters: {
     validate: process.env.BABEL_8_BREAKING
       ? assertNodeType("TSTypeParameterDeclaration")
-      : assertNodeType("TSTypeParameterDeclaration", "Noop"),
+      : // @ts-ignore Babel 7 AST
+        assertNodeType("TSTypeParameterDeclaration", "Noop"),
     optional: true,
   },
 };
@@ -179,7 +181,7 @@ const tsKeywordTypes = [
   "TSUndefinedKeyword",
   "TSUnknownKeyword",
   "TSVoidKeyword",
-];
+] as const;
 
 for (const type of tsKeywordTypes) {
   defineType(type, {
@@ -358,9 +360,9 @@ defineType("TSMappedType", {
   aliases: ["TSType"],
   visitor: ["typeParameter", "typeAnnotation", "nameType"],
   fields: {
-    readonly: validateOptional(bool),
+    readonly: validateOptional(assertOneOf(true, false, "+", "-")),
     typeParameter: validateType("TSTypeParameter"),
-    optional: validateOptional(bool),
+    optional: validateOptional(assertOneOf(true, false, "+", "-")),
     typeAnnotation: validateOptionalType("TSType"),
     nameType: validateOptionalType("TSType"),
   },
@@ -384,7 +386,7 @@ defineType("TSLiteralType", {
           "BooleanLiteral",
           "BigIntLiteral",
         );
-        function validator(parent, key: string, node) {
+        function validator(parent: any, key: string, node: any) {
           // type A = -1 | 1;
           if (is("UnaryExpression", node)) {
             // check operator first
diff --git a/packages/babel-types/src/definitions/utils.ts b/packages/babel-types/src/definitions/utils.ts
index 6ed5ce96b370..687b907ef07c 100644
--- a/packages/babel-types/src/definitions/utils.ts
+++ b/packages/babel-types/src/definitions/utils.ts
@@ -1,15 +1,16 @@
 import is from "../validators/is";
 import { validateField, validateChild } from "../validators/validate";
+import type * as t from "..";
 
 export const VISITOR_KEYS: Record<string, string[]> = {};
 export const ALIAS_KEYS: Record<string, string[]> = {};
 export const FLIPPED_ALIAS_KEYS: Record<string, string[]> = {};
-export const NODE_FIELDS: Record<string, {}> = {};
+export const NODE_FIELDS: Record<string, FieldDefinitions> = {};
 export const BUILDER_KEYS: Record<string, string[]> = {};
 export const DEPRECATED_KEYS: Record<string, string> = {};
-export const NODE_PARENT_VALIDATIONS = {};
+export const NODE_PARENT_VALIDATIONS: Record<string, Validator> = {};
 
-function getType(val) {
+function getType(val: any) {
   if (Array.isArray(val)) {
     return "array";
   } else if (val === null) {
@@ -19,32 +20,37 @@ function getType(val) {
   }
 }
 
+type NodeTypes = t.Node["type"] | t.Comment["type"] | keyof t.Aliases;
+
+type PrimitiveTypes = ReturnType<typeof getType>;
+
+type FieldDefinitions = {
+  [x: string]: FieldOptions;
+};
+
 type DefineTypeOpts = {
-  fields?: {
-    [x: string]: FieldOptions;
-  };
+  fields?: FieldDefinitions;
   visitor?: Array<string>;
   aliases?: Array<string>;
   builder?: Array<string>;
-  inherits?: string;
+  inherits?: NodeTypes;
   deprecatedAlias?: string;
   validate?: Validator;
 };
 
-type Validator = (
-  | { type: string }
+export type Validator = (
+  | { type: PrimitiveTypes }
   | { each: Validator }
   | { chainOf: Validator[] }
   | { oneOf: any[] }
-  | { oneOfNodeTypes: string[] }
-  | { oneOfNodeOrValueTypes: string[] }
+  | { oneOfNodeTypes: NodeTypes[] }
+  | { oneOfNodeOrValueTypes: (NodeTypes | PrimitiveTypes)[] }
   | { shapeOf: { [x: string]: FieldOptions } }
   | {}
 ) &
-  // TODO: Import and use Node instead of any
-  ((parent: any, key: string, node: any) => void);
+  ((node: t.Node, key: string, val: any) => void);
 
-type FieldOptions = {
+export type FieldOptions = {
   default?: any;
   optional?: boolean;
   validate?: Validator;
@@ -54,13 +60,13 @@ export function validate(validate: Validator): FieldOptions {
   return { validate };
 }
 
-export function typeIs(typeName: string | string[]) {
+export function typeIs(typeName: NodeTypes | NodeTypes[]) {
   return typeof typeName === "string"
     ? assertNodeType(typeName)
     : assertNodeType(...typeName);
 }
 
-export function validateType(typeName: string | string[]) {
+export function validateType(typeName: NodeTypes | NodeTypes[]) {
   return validate(typeIs(typeName));
 }
 
@@ -69,7 +75,7 @@ export function validateOptional(validate: Validator): FieldOptions {
 }
 
 export function validateOptionalType(
-  typeName: string | string[],
+  typeName: NodeTypes | NodeTypes[],
 ): FieldOptions {
   return { validate: typeIs(typeName), optional: true };
 }
@@ -78,16 +84,16 @@ export function arrayOf(elementType: Validator): Validator {
   return chain(assertValueType("array"), assertEach(elementType));
 }
 
-export function arrayOfType(typeName: string | string[]) {
+export function arrayOfType(typeName: NodeTypes | NodeTypes[]) {
   return arrayOf(typeIs(typeName));
 }
 
-export function validateArrayOfType(typeName: string | string[]) {
+export function validateArrayOfType(typeName: NodeTypes | NodeTypes[]) {
   return validate(arrayOfType(typeName));
 }
 
 export function assertEach(callback: Validator): Validator {
-  function validator(node, key, val) {
+  function validator(node: t.Node, key: string, val: any) {
     if (!Array.isArray(val)) return;
 
     for (let i = 0; i < val.length; i++) {
@@ -117,8 +123,8 @@ export function assertOneOf(...values: Array<any>): Validator {
   return validate;
 }
 
-export function assertNodeType(...types: Array<string>): Validator {
-  function validate(node, key, val) {
+export function assertNodeType(...types: NodeTypes[]): Validator {
+  function validate(node: t.Node, key: string, val: any) {
     for (const type of types) {
       if (is(type, val)) {
         validateChild(node, key, val);
@@ -140,8 +146,10 @@ export function assertNodeType(...types: Array<string>): Validator {
   return validate;
 }
 
-export function assertNodeOrValueType(...types: Array<string>): Validator {
-  function validate(node, key, val) {
+export function assertNodeOrValueType(
+  ...types: (NodeTypes | PrimitiveTypes)[]
+): Validator {
+  function validate(node: t.Node, key: string, val: any) {
     for (const type of types) {
       if (getType(val) === type || is(type, val)) {
         validateChild(node, key, val);
@@ -163,8 +171,8 @@ export function assertNodeOrValueType(...types: Array<string>): Validator {
   return validate;
 }
 
-export function assertValueType(type: string): Validator {
-  function validate(node, key, val) {
+export function assertValueType(type: PrimitiveTypes): Validator {
+  function validate(node: t.Node, key: string, val: any) {
     const valid = getType(val) === type;
 
     if (!valid) {
@@ -180,7 +188,7 @@ export function assertValueType(type: string): Validator {
 }
 
 export function assertShape(shape: { [x: string]: FieldOptions }): Validator {
-  function validate(node, key, val) {
+  function validate(node: t.Node, key: string, val: any) {
     const errors = [];
     for (const property of Object.keys(shape)) {
       try {
@@ -208,7 +216,7 @@ export function assertShape(shape: { [x: string]: FieldOptions }): Validator {
 }
 
 export function assertOptionalChainStart(): Validator {
-  function validate(node) {
+  function validate(node: t.Node) {
     let current = node;
     while (node) {
       const { type } = current;
@@ -365,4 +373,4 @@ export default function defineType(type: string, opts: DefineTypeOpts = {}) {
   store[type] = opts;
 }
 
-const store = {};
+const store = {} as Record<string, DefineTypeOpts>;
diff --git a/packages/babel-types/src/index.ts b/packages/babel-types/src/index.ts
index d80b74ee7024..f7c1f083be07 100644
--- a/packages/babel-types/src/index.ts
+++ b/packages/babel-types/src/index.ts
@@ -54,7 +54,10 @@ export * from "./definitions";
 export { default as appendToMemberExpression } from "./modifications/appendToMemberExpression";
 export { default as inherits } from "./modifications/inherits";
 export { default as prependToMemberExpression } from "./modifications/prependToMemberExpression";
-export { default as removeProperties } from "./modifications/removeProperties";
+export {
+  default as removeProperties,
+  type Options as RemovePropertiesOptions,
+} from "./modifications/removeProperties";
 export { default as removePropertiesDeep } from "./modifications/removePropertiesDeep";
 export { default as removeTypeDuplicates } from "./modifications/flow/removeTypeDuplicates";
 
diff --git a/packages/babel-types/src/modifications/flow/removeTypeDuplicates.ts b/packages/babel-types/src/modifications/flow/removeTypeDuplicates.ts
index 717b993d5a0d..f9885552a00d 100644
--- a/packages/babel-types/src/modifications/flow/removeTypeDuplicates.ts
+++ b/packages/babel-types/src/modifications/flow/removeTypeDuplicates.ts
@@ -7,7 +7,7 @@ import {
 } from "../../validators/generated";
 import type * as t from "../..";
 
-function getQualifiedName(node: t.GenericTypeAnnotation["id"]) {
+function getQualifiedName(node: t.GenericTypeAnnotation["id"]): string {
   return isIdentifier(node)
     ? node.name
     : `${node.id.name}.${getQualifiedName(node.qualification)}`;
@@ -20,13 +20,16 @@ export default function removeTypeDuplicates(
   // todo(babel-8): change type to Array<...>
   nodes: ReadonlyArray<t.FlowType | false | null | undefined>,
 ): t.FlowType[] {
-  const generics = {};
-  const bases = {};
+  const generics: Record<string, t.GenericTypeAnnotation> = {};
+  const bases = {} as Record<
+    t.FlowBaseAnnotation["type"],
+    t.FlowBaseAnnotation
+  >;
 
   // store union type groups to circular references
   const typeGroups = new Set<t.FlowType[]>();
 
-  const types = [];
+  const types: t.FlowType[] = [];
 
   for (let i = 0; i < nodes.length; i++) {
     const node = nodes[i];
@@ -61,7 +64,7 @@ export default function removeTypeDuplicates(
       const name = getQualifiedName(node.id);
 
       if (generics[name]) {
-        let existing = generics[name];
+        let existing: t.Flow = generics[name];
         if (existing.typeParameters) {
           if (node.typeParameters) {
             existing.typeParameters.params = removeTypeDuplicates(
@@ -82,7 +85,7 @@ export default function removeTypeDuplicates(
   }
 
   // add back in bases
-  for (const type of Object.keys(bases)) {
+  for (const type of Object.keys(bases) as (keyof typeof bases)[]) {
     types.push(bases[type]);
   }
 
diff --git a/packages/babel-types/src/modifications/inherits.ts b/packages/babel-types/src/modifications/inherits.ts
index d426ee44c5c4..5fbf401b15c7 100644
--- a/packages/babel-types/src/modifications/inherits.ts
+++ b/packages/babel-types/src/modifications/inherits.ts
@@ -13,18 +13,24 @@ export default function inherits<T extends t.Node | null | undefined>(
 
   // optionally inherit specific properties if not null
   for (const key of INHERIT_KEYS.optional) {
+    // @ts-expect-error Fixme: refine parent types
     if (child[key] == null) {
+      // @ts-expect-error Fixme: refine parent types
       child[key] = parent[key];
     }
   }
 
   // force inherit "private" properties
   for (const key of Object.keys(parent)) {
-    if (key[0] === "_" && key !== "__clone") child[key] = parent[key];
+    if (key[0] === "_" && key !== "__clone") {
+      // @ts-expect-error Fixme: refine parent types
+      child[key] = parent[key];
+    }
   }
 
   // force inherit select properties
   for (const key of INHERIT_KEYS.force) {
+    // @ts-expect-error Fixme: refine parent types
     child[key] = parent[key];
   }
 
diff --git a/packages/babel-types/src/modifications/removeProperties.ts b/packages/babel-types/src/modifications/removeProperties.ts
index 38e4595ed9a4..75aa841dc9da 100644
--- a/packages/babel-types/src/modifications/removeProperties.ts
+++ b/packages/babel-types/src/modifications/removeProperties.ts
@@ -1,31 +1,45 @@
 import { COMMENT_KEYS } from "../constants";
 import type * as t from "..";
 
-const CLEAR_KEYS = ["tokens", "start", "end", "loc", "raw", "rawValue"];
+const CLEAR_KEYS = [
+  "tokens", // only exist in t.File
+  "start",
+  "end",
+  "loc",
+  // Fixme: should be extra.raw / extra.rawValue?
+  "raw",
+  "rawValue",
+] as const;
 
-const CLEAR_KEYS_PLUS_COMMENTS = COMMENT_KEYS.concat(["comments"]).concat(
-  CLEAR_KEYS,
-);
+const CLEAR_KEYS_PLUS_COMMENTS = [
+  ...COMMENT_KEYS,
+  "comments",
+  ...CLEAR_KEYS,
+] as const;
 
+export type Options = { preserveComments?: boolean };
 /**
  * Remove all of the _* properties from a node along with the additional metadata
  * properties like location data and raw token data.
  */
 export default function removeProperties(
   node: t.Node,
-  opts: { preserveComments?: boolean } = {},
+  opts: Options = {},
 ): void {
   const map = opts.preserveComments ? CLEAR_KEYS : CLEAR_KEYS_PLUS_COMMENTS;
   for (const key of map) {
+    // @ts-ignore
     if (node[key] != null) node[key] = undefined;
   }
 
   for (const key of Object.keys(node)) {
+    // @ts-ignore
     if (key[0] === "_" && node[key] != null) node[key] = undefined;
   }
 
   const symbols: Array<symbol> = Object.getOwnPropertySymbols(node);
   for (const sym of symbols) {
+    // @ts-ignore Fixme: document symbol properties
     node[sym] = null;
   }
 }
diff --git a/packages/babel-types/src/modifications/typescript/removeTypeDuplicates.ts b/packages/babel-types/src/modifications/typescript/removeTypeDuplicates.ts
index da5c565f198f..28f811a4e86c 100644
--- a/packages/babel-types/src/modifications/typescript/removeTypeDuplicates.ts
+++ b/packages/babel-types/src/modifications/typescript/removeTypeDuplicates.ts
@@ -12,12 +12,12 @@ export default function removeTypeDuplicates(
   nodes: Array<t.TSType>,
 ): Array<t.TSType> {
   const generics = {};
-  const bases = {};
+  const bases = {} as Record<t.TSBaseType["type"], t.TSBaseType>;
 
   // store union type groups to circular references
   const typeGroups = new Set<t.TSType[]>();
 
-  const types = [];
+  const types: t.TSType[] = [];
 
   for (let i = 0; i < nodes.length; i++) {
     const node = nodes[i];
@@ -53,13 +53,16 @@ export default function removeTypeDuplicates(
   }
 
   // add back in bases
-  for (const type of Object.keys(bases)) {
+  for (const type of Object.keys(bases) as (keyof typeof bases)[]) {
     types.push(bases[type]);
   }
 
   // add back in generics
   for (const name of Object.keys(generics)) {
-    types.push(generics[name]);
+    types.push(
+      // @ts-ignore generics are not implemented
+      generics[name],
+    );
   }
 
   return types;
diff --git a/packages/babel-types/src/retrievers/getBindingIdentifiers.ts b/packages/babel-types/src/retrievers/getBindingIdentifiers.ts
index 81b5a9ce1ad0..7e611397343b 100644
--- a/packages/babel-types/src/retrievers/getBindingIdentifiers.ts
+++ b/packages/babel-types/src/retrievers/getBindingIdentifiers.ts
@@ -36,14 +36,16 @@ function getBindingIdentifiers(
   duplicates?: boolean,
   outerOnly?: boolean,
 ): Record<string, t.Identifier> | Record<string, Array<t.Identifier>> {
-  let search = [].concat(node);
+  const search: t.Node[] = [].concat(node);
   const ids = Object.create(null);
 
   while (search.length) {
     const id = search.shift();
     if (!id) continue;
 
-    const keys = getBindingIdentifiers.keys[id.type];
+    const keys =
+      // @ts-expect-error getBindingIdentifiers.keys do not cover all AST types
+      getBindingIdentifiers.keys[id.type];
 
     if (isIdentifier(id)) {
       if (duplicates) {
@@ -76,8 +78,11 @@ function getBindingIdentifiers(
     if (keys) {
       for (let i = 0; i < keys.length; i++) {
         const key = keys[i];
-        if (id[key]) {
-          search = search.concat(id[key]);
+        const nodes =
+          // @ts-ignore key must present in id
+          id[key] as t.Node[] | t.Node | undefined | null;
+        if (nodes) {
+          Array.isArray(nodes) ? search.push(...nodes) : search.push(nodes);
         }
       }
     }
diff --git a/packages/babel-types/src/traverse/traverseFast.ts b/packages/babel-types/src/traverse/traverseFast.ts
index d0dc3376957f..66a8f65854fa 100644
--- a/packages/babel-types/src/traverse/traverseFast.ts
+++ b/packages/babel-types/src/traverse/traverseFast.ts
@@ -5,22 +5,23 @@ import type * as t from "..";
  * A prefix AST traversal implementation meant for simple searching
  * and processing.
  */
-export default function traverseFast(
+export default function traverseFast<Options = {}>(
   node: t.Node | null | undefined,
-  enter: (node: t.Node, opts?: any) => void,
-  // todo(flow->ts) We could parametrize opts to T rather than any, so that the type is "forwarded" to the callback.
-  opts?: any,
+  enter: (node: t.Node, opts?: Options) => void,
+  opts?: Options,
 ): void {
   if (!node) return;
 
   const keys = VISITOR_KEYS[node.type];
   if (!keys) return;
 
-  opts = opts || {};
+  opts = opts || ({} as Options);
   enter(node, opts);
 
   for (const key of keys) {
-    const subNode = node[key];
+    const subNode: t.Node | undefined | null =
+      // @ts-ignore key must present in node
+      node[key];
 
     if (Array.isArray(subNode)) {
       for (const node of subNode) {
diff --git a/packages/babel-types/src/utils/inherit.ts b/packages/babel-types/src/utils/inherit.ts
index 53e65be848c7..bf561c22d38a 100644
--- a/packages/babel-types/src/utils/inherit.ts
+++ b/packages/babel-types/src/utils/inherit.ts
@@ -1,11 +1,11 @@
 import type * as t from "..";
 
-export default function inherit(
-  key: string,
-  child: t.Node,
-  parent: t.Node,
-): void {
+export default function inherit<
+  C extends t.Node | undefined,
+  P extends t.Node | undefined,
+>(key: keyof C & keyof P, child: C, parent: P): void {
   if (child && parent) {
+    // @ts-ignore Could further refine key definitions
     child[key] = Array.from(
       new Set([].concat(child[key], parent[key]).filter(Boolean)),
     );
diff --git a/packages/babel-types/src/utils/shallowEqual.ts b/packages/babel-types/src/utils/shallowEqual.ts
index 98ddebcd7db3..7da3e99b08e4 100644
--- a/packages/babel-types/src/utils/shallowEqual.ts
+++ b/packages/babel-types/src/utils/shallowEqual.ts
@@ -2,10 +2,13 @@ export default function shallowEqual<T extends object>(
   actual: object,
   expected: T,
 ): actual is T {
-  const keys = Object.keys(expected);
+  const keys = Object.keys(expected) as (keyof T)[];
 
   for (const key of keys) {
-    if (actual[key] !== expected[key]) {
+    if (
+      // @ts-ignore maybe we should check whether key exists first
+      actual[key] !== expected[key]
+    ) {
       return false;
     }
   }
diff --git a/packages/babel-types/src/validators/isBinding.ts b/packages/babel-types/src/validators/isBinding.ts
index a91ad6306e7a..4af7de6dea04 100644
--- a/packages/babel-types/src/validators/isBinding.ts
+++ b/packages/babel-types/src/validators/isBinding.ts
@@ -19,11 +19,15 @@ export default function isBinding(
     return false;
   }
 
-  const keys = getBindingIdentifiers.keys[parent.type];
+  const keys =
+    // @ts-expect-error getBindingIdentifiers.keys does not cover all AST types
+    getBindingIdentifiers.keys[parent.type];
   if (keys) {
     for (let i = 0; i < keys.length; i++) {
       const key = keys[i];
-      const val = parent[key];
+      const val =
+        // @ts-expect-error key must present in parent
+        parent[key];
       if (Array.isArray(val)) {
         if (val.indexOf(node) >= 0) return true;
       } else {
diff --git a/packages/babel-types/src/validators/isLet.ts b/packages/babel-types/src/validators/isLet.ts
index 06450cb9b490..893638ba4c8a 100644
--- a/packages/babel-types/src/validators/isLet.ts
+++ b/packages/babel-types/src/validators/isLet.ts
@@ -8,6 +8,8 @@ import type * as t from "..";
 export default function isLet(node: t.Node): boolean {
   return (
     isVariableDeclaration(node) &&
-    (node.kind !== "var" || node[BLOCK_SCOPED_SYMBOL])
+    (node.kind !== "var" ||
+      // @ts-ignore Fixme: document private properties
+      node[BLOCK_SCOPED_SYMBOL])
   );
 }
diff --git a/packages/babel-types/src/validators/isNodesEquivalent.ts b/packages/babel-types/src/validators/isNodesEquivalent.ts
index 93a74b62164c..6cdb3c561cbb 100644
--- a/packages/babel-types/src/validators/isNodesEquivalent.ts
+++ b/packages/babel-types/src/validators/isNodesEquivalent.ts
@@ -25,41 +25,45 @@ export default function isNodesEquivalent<T extends Partial<t.Node>>(
   const visitorKeys = VISITOR_KEYS[a.type];
 
   for (const field of fields) {
-    if (typeof a[field] !== typeof b[field]) {
+    const val_a =
+      // @ts-ignore field must present in a
+      a[field];
+    const val_b = b[field];
+    if (typeof val_a !== typeof val_b) {
       return false;
     }
-    if (a[field] == null && b[field] == null) {
+    if (val_a == null && val_b == null) {
       continue;
-    } else if (a[field] == null || b[field] == null) {
+    } else if (val_a == null || val_b == null) {
       return false;
     }
 
-    if (Array.isArray(a[field])) {
-      if (!Array.isArray(b[field])) {
+    if (Array.isArray(val_a)) {
+      if (!Array.isArray(val_b)) {
         return false;
       }
-      if (a[field].length !== b[field].length) {
+      if (val_a.length !== val_b.length) {
         return false;
       }
 
-      for (let i = 0; i < a[field].length; i++) {
-        if (!isNodesEquivalent(a[field][i], b[field][i])) {
+      for (let i = 0; i < val_a.length; i++) {
+        if (!isNodesEquivalent(val_a[i], val_b[i])) {
           return false;
         }
       }
       continue;
     }
 
-    if (typeof a[field] === "object" && !visitorKeys?.includes(field)) {
-      for (const key of Object.keys(a[field])) {
-        if (a[field][key] !== b[field][key]) {
+    if (typeof val_a === "object" && !visitorKeys?.includes(field)) {
+      for (const key of Object.keys(val_a)) {
+        if (val_a[key] !== val_b[key]) {
           return false;
         }
       }
       continue;
     }
 
-    if (!isNodesEquivalent(a[field], b[field])) {
+    if (!isNodesEquivalent(val_a, val_b)) {
       return false;
     }
   }
diff --git a/packages/babel-types/src/validators/isVar.ts b/packages/babel-types/src/validators/isVar.ts
index 6eca80cd8d8d..b320e18759c2 100644
--- a/packages/babel-types/src/validators/isVar.ts
+++ b/packages/babel-types/src/validators/isVar.ts
@@ -7,6 +7,10 @@ import type * as t from "..";
  */
 export default function isVar(node: t.Node): boolean {
   return (
-    isVariableDeclaration(node, { kind: "var" }) && !node[BLOCK_SCOPED_SYMBOL]
+    isVariableDeclaration(node, { kind: "var" }) &&
+    !(
+      // @ts-ignore document private properties
+      node[BLOCK_SCOPED_SYMBOL]
+    )
   );
 }
diff --git a/packages/babel-types/src/validators/validate.ts b/packages/babel-types/src/validators/validate.ts
index 28bd5397dfb7..82bf11589414 100644
--- a/packages/babel-types/src/validators/validate.ts
+++ b/packages/babel-types/src/validators/validate.ts
@@ -1,4 +1,8 @@
-import { NODE_FIELDS, NODE_PARENT_VALIDATIONS } from "../definitions";
+import {
+  NODE_FIELDS,
+  NODE_PARENT_VALIDATIONS,
+  type FieldOptions,
+} from "../definitions";
 import type * as t from "..";
 
 export default function validate(
@@ -20,7 +24,7 @@ export function validateField(
   node: t.Node | undefined | null,
   key: string,
   val: any,
-  field: any,
+  field: FieldOptions | undefined | null,
 ): void {
   if (!field?.validate) return;
   if (field.optional && val == null) return;
@@ -31,7 +35,7 @@ export function validateField(
 export function validateChild(
   node: t.Node | undefined | null,
   key: string,
-  val?: any,
+  val?: t.Node | undefined | null,
 ) {
   if (val == null) return;
   const validate = NODE_PARENT_VALIDATIONS[val.type];
diff --git a/scripts/generators/tsconfig.js b/scripts/generators/tsconfig.js
index c56c455db0a5..ad9d0d203b75 100644
--- a/scripts/generators/tsconfig.js
+++ b/scripts/generators/tsconfig.js
@@ -116,6 +116,13 @@ fs.writeFileSync(
               "babel-plugin-dynamic-import-node/utils",
               ["./lib/babel-plugin-dynamic-import-node.d.ts"],
             ],
+            ["globals", ["./node_modules/globals-BABEL_8_BREAKING-true"]],
+            ["js-tokens", ["./node_modules/js-tokens-BABEL_8_BREAKING-true"]],
+            ["regexpu-core", ["./lib/regexpu-core.d.ts"]],
+            [
+              "to-fast-properties",
+              ["./node_modules/to-fast-properties-BABEL_8_BREAKING-true"],
+            ],
           ]),
         },
       },
diff --git a/tsconfig.base.json b/tsconfig.base.json
index af2501b34cc3..64b95c92c311 100644
--- a/tsconfig.base.json
+++ b/tsconfig.base.json
@@ -12,6 +12,7 @@
     "isolatedModules": true,
     "skipLibCheck": true,
     "resolveJsonModule": true,
-    "noImplicitThis": true
+    "noImplicitThis": true,
+    "noImplicitAny": true
   }
 }
diff --git a/tsconfig.json b/tsconfig.json
index 17553efa7cab..d2eba9b804cf 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -698,6 +698,18 @@
       ],
       "babel-plugin-dynamic-import-node/utils": [
         "./lib/babel-plugin-dynamic-import-node.d.ts"
+      ],
+      "globals": [
+        "./node_modules/globals-BABEL_8_BREAKING-true"
+      ],
+      "js-tokens": [
+        "./node_modules/js-tokens-BABEL_8_BREAKING-true"
+      ],
+      "regexpu-core": [
+        "./lib/regexpu-core.d.ts"
+      ],
+      "to-fast-properties": [
+        "./node_modules/to-fast-properties-BABEL_8_BREAKING-true"
       ]
     }
   }
diff --git a/yarn.lock b/yarn.lock
index 48f04c6804fd..7de9a3584102 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -1302,6 +1302,7 @@ __metadata:
     "@babel/helper-split-export-declaration": "workspace:^"
     "@babel/plugin-syntax-decorators": "workspace:^"
     "@babel/traverse": "workspace:^"
+    "@types/charcodes": ^0.2.0
     babel-plugin-polyfill-es-shims: ^0.6.1
     charcodes: ^0.2.0
     object.getownpropertydescriptors: ^2.1.1
@@ -3798,7 +3799,7 @@ __metadata:
     "@babel/parser": "workspace:^"
     chalk: ^4.1.0
     glob: ^7.1.7
-    to-fast-properties: ^2.0.0
+    to-fast-properties: "condition:BABEL_8_BREAKING ? ^3.0.0 : ^2.0.0"
   languageName: unknown
   linkType: soft
 
@@ -4374,6 +4375,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@types/charcodes@npm:^0.2.0":
+  version: 0.2.0
+  resolution: "@types/charcodes@npm:0.2.0"
+  checksum: 3403a591f7dba4164a2a1a48342855a0eee0e22f4f94903c39331339c4e96006ba4f9d5b81072bcd8f61f15d774891b6bb9f3cbe1fb202d558d9ae90f35baa49
+  languageName: node
+  linkType: hard
+
 "@types/color-name@npm:^1.1.1":
   version: 1.1.1
   resolution: "@types/color-name@npm:1.1.1"
@@ -14708,13 +14716,30 @@ fsevents@^1.2.7:
   languageName: node
   linkType: hard
 
-"to-fast-properties@npm:^2.0.0":
+"to-fast-properties-BABEL_8_BREAKING-false@npm:to-fast-properties@^2.0.0, to-fast-properties@npm:^2.0.0":
   version: 2.0.0
   resolution: "to-fast-properties@npm:2.0.0"
   checksum: be2de62fe58ead94e3e592680052683b1ec986c72d589e7b21e5697f8744cdbf48c266fa72f6c15932894c10187b5f54573a3bcf7da0bfd964d5caf23d436168
   languageName: node
   linkType: hard
 
+"to-fast-properties-BABEL_8_BREAKING-true@npm:to-fast-properties@^3.0.0":
+  version: 3.0.1
+  resolution: "to-fast-properties@npm:3.0.1"
+  checksum: 66b79f2c0d420d116a4eeb781c87c8c6b2de426a15f16118759e706aa1111833b0c578355a1108514ada966c08f4dba0cb7994aca025d80a535a139f7a631e22
+  languageName: node
+  linkType: hard
+
+"to-fast-properties@condition:BABEL_8_BREAKING ? ^3.0.0 : ^2.0.0":
+  version: 0.0.0-condition-8fb1fb
+  resolution: "to-fast-properties@condition:BABEL_8_BREAKING?^3.0.0:^2.0.0#8fb1fb"
+  dependencies:
+    to-fast-properties-BABEL_8_BREAKING-false: "npm:to-fast-properties@^2.0.0"
+    to-fast-properties-BABEL_8_BREAKING-true: "npm:to-fast-properties@^3.0.0"
+  checksum: 6c5259ab91c280bfa3d2db3edd2fa26be985fd06f63974d0c288391426523f9d70035a812d05b65fe0e3fef864d969fcc3630b441cb563693e3ec70c54def266
+  languageName: node
+  linkType: hard
+
 "to-object-path@npm:^0.3.0":
   version: 0.3.0
   resolution: "to-object-path@npm:0.3.0"