[babel 8] Publish .d.ts for every package

[nicolo-ribaudo]

Q	A
Fixed Issues?	Fixes #1, Fixes #2
Patch: Bug Fix?
Major: Breaking Change?
Minor: New Feature?
Tests Added + Pass?	Yes
Documentation PR Link
Any Dependency Changes?
License	MIT

Some examples:

@babel/plugin-proposal-decorators

import * as _babel_core from '@babel/core';
import { Options as Options$1 } from '@babel/plugin-syntax-decorators';

interface Options extends Options$1 {
    /** @deprecated use `constantSuper` assumption instead. Only supported in 2021-12 version. */
    loose?: boolean;
}

declare const _default: (api: _babel_core.PluginAPI, options: Options, dirname: string) => _babel_core.PluginObject<_babel_core.PluginPass<{}>>;

export { type Options, _default as default };

@babel/preset-env

import * as _babel_core from '@babel/core';
import { InputTargets, Targets } from '@babel/helper-compilation-targets';

declare const ModulesOption: {
    readonly false: false;
    readonly auto: "auto";
    readonly amd: "amd";
    readonly commonjs: "commonjs";
    readonly cjs: "cjs";
    readonly systemjs: "systemjs";
    readonly umd: "umd";
};
declare const UseBuiltInsOption: {
    readonly false: false;
    readonly entry: "entry";
    readonly usage: "usage";
};

// Options
// Use explicit modules to prevent typo errors.
type ModuleOption = (typeof ModulesOption)[keyof typeof ModulesOption];
type BuiltInsOption =
  (typeof UseBuiltInsOption)[keyof typeof UseBuiltInsOption];

type CorejsVersion = 2 | 3 | string;

type CorejsOption =
  | false
  | CorejsVersion
  | {
      version: CorejsVersion;
      proposals: boolean;
    };

type PluginListItem = string | RegExp;
type PluginListOption = Array<PluginListItem>;

type Options = {
  bugfixes: boolean;
  configPath: string;
  corejs: CorejsOption;
  debug: boolean;
  exclude: PluginListOption;
  forceAllTransforms: boolean;
  ignoreBrowserslistConfig: boolean;
  include: PluginListOption;
  modules: ModuleOption;
  shippedProposals: boolean;
  targets: {
    uglify?: boolean;
    esmodules?: boolean;
  } & InputTargets;
  useBuiltIns: BuiltInsOption;
  browserslistEnv: string;

  // TODO(Babel 8): Remove these options
  loose: boolean;
  spec: boolean;
};

declare function isPluginRequired(targets: Targets, support: Targets): boolean;
declare const transformIncludesAndExcludes: (opts: Array<string>) => any;
declare const _default: (api: _babel_core.PresetAPI, options: Options, dirname: string) => _babel_core.PresetObject;

export { _default as default, isPluginRequired, transformIncludesAndExcludes };

@babel/core

import traverse, { Visitor, NodePath, Scope, HubInterface } from '@babel/traverse';
export { default as traverse } from '@babel/traverse';
import * as t from '@babel/types';
export { t as types };
import { SourceMapConverter } from 'convert-source-map';
import { Targets, InputTargets } from '@babel/helper-compilation-targets';
import gensync, { Handler } from 'gensync';
import { ParserOptions, File as File$1, tokTypes } from '@babel/parser';
export { tokTypes } from '@babel/parser';
import { GeneratorOptions, GeneratorResult } from '@babel/generator';
import template from '@babel/template';
export { default as template } from '@babel/template';

type ___CallerMetadata = CallerMetadata;
type ___ConfigItem<API> = ConfigItem<API>;
declare const ___ConfigItem: typeof ConfigItem;
declare const ___DEFAULT_EXTENSIONS: typeof DEFAULT_EXTENSIONS;
type ___File = File;
declare const ___File: typeof File;
type ___FileResult = FileResult;
type ___InputOptions = InputOptions;
type ___PluginAPI = PluginAPI;
type ___PluginObject<S extends PluginPass = PluginPass> = PluginObject<S>;
type ___PluginPass<Options = {}> = PluginPass<Options>;
declare const ___PluginPass: typeof PluginPass;
type ___PresetAPI = PresetAPI;
declare const ___createConfigItem: typeof createConfigItem;
declare const ___createConfigItemAsync: typeof createConfigItemAsync;
declare const ___createConfigItemSync: typeof createConfigItemSync;
declare const ___getEnv: typeof getEnv;
declare const ___loadOptions: typeof loadOptions;
declare const ___loadOptionsAsync: typeof loadOptionsAsync;
declare const ___loadOptionsSync: typeof loadOptionsSync;
declare const ___loadPartialConfig: typeof loadPartialConfig;
declare const ___loadPartialConfigAsync: typeof loadPartialConfigAsync;
declare const ___loadPartialConfigSync: typeof loadPartialConfigSync;
declare const ___parse: typeof parse;
declare const ___parseAsync: typeof parseAsync;
declare const ___parseSync: typeof parseSync;
declare const ___resolvePlugin: typeof resolvePlugin;
declare const ___resolvePreset: typeof resolvePreset;
declare const ___template: typeof template;
declare const ___tokTypes: typeof tokTypes;
declare const ___transform: typeof transform;
declare const ___transformAsync: typeof transformAsync;
declare const ___transformFile: typeof transformFile;
declare const ___transformFileAsync: typeof transformFileAsync;
declare const ___transformFileSync: typeof transformFileSync;
declare const ___transformFromAst: typeof transformFromAst;
declare const ___transformFromAstAsync: typeof transformFromAstAsync;
declare const ___transformFromAstSync: typeof transformFromAstSync;
declare const ___transformSync: typeof transformSync;
declare const ___traverse: typeof traverse;
declare const ___version: typeof version;
declare namespace __ {
  export { type ___CallerMetadata as CallerMetadata, ___ConfigItem as ConfigItem, ___DEFAULT_EXTENSIONS as DEFAULT_EXTENSIONS, ___File as File, type ___FileResult as FileResult, type ___InputOptions as InputOptions, type ___PluginAPI as PluginAPI, type ___PluginObject as PluginObject, ___PluginPass as PluginPass, type ___PresetAPI as PresetAPI, type ValidatedOptions as PresetObject, export_default as buildExternalHelpers, ___createConfigItem as createConfigItem, ___createConfigItemAsync as createConfigItemAsync, ___createConfigItemSync as createConfigItemSync, ___getEnv as getEnv, ___loadOptions as loadOptions, ___loadOptionsAsync as loadOptionsAsync, ___loadOptionsSync as loadOptionsSync, ___loadPartialConfig as loadPartialConfig, ___loadPartialConfigAsync as loadPartialConfigAsync, ___loadPartialConfigSync as loadPartialConfigSync, ___parse as parse, ___parseAsync as parseAsync, ___parseSync as parseSync, ___resolvePlugin as resolvePlugin, ___resolvePreset as resolvePreset, ___template as template, ___tokTypes as tokTypes, ___transform as transform, ___transformAsync as transformAsync, ___transformFile as transformFile, ___transformFileAsync as transformFileAsync, ___transformFileSync as transformFileSync, ___transformFromAst as transformFromAst, ___transformFromAstAsync as transformFromAstAsync, ___transformFromAstSync as transformFromAstSync, ___transformSync as transformSync, ___traverse as traverse, t as types, ___version as version };
}

type SimpleCacheConfigurator = {
    (forever: boolean): void;
    <T>(handler: () => T): T;
    forever: () => void;
    never: () => void;
    using: <T>(handler: () => T) => T;
    invalidate: <T>(handler: () => T) => T;
};
type SimpleType = string | boolean | number | null | void | Promise<SimpleType>;

declare const __marker: unique symbol;
type ReadonlyDeepArray<T> = ReadonlyArray<T | ReadonlyDeepArray<T>> & {
    [__marker]: true;
};

/**
 * This file handles all logic for converting string-based configuration references into loaded objects.
 */

declare const resolvePlugin: (name: string, dirname: string, resolveESM: boolean) => string;
declare const resolvePreset: (name: string, dirname: string, resolveESM: boolean) => string;

type FileHandling = "transpile" | "ignored" | "unsupported";

type EnvFunction = {
    (): string;
    <T>(extractor: (babelEnv: string) => T): T;
    (envVar: string): boolean;
    (envVars: Array<string>): boolean;
};
type CallerFactory = {
    <T extends SimpleType>(extractor: (callerMetadata: CallerMetadata | undefined) => T): T;
    (extractor: (callerMetadata: CallerMetadata | undefined) => unknown): SimpleType;
};
type TargetsFunction = () => Targets;
type AssumptionFunction = (name: AssumptionName) => boolean | undefined;
type ConfigAPI = {
    version: string;
    cache: SimpleCacheConfigurator;
    env: EnvFunction;
    async: () => boolean;
    assertVersion: typeof assertVersion;
    caller?: CallerFactory;
};
type PresetAPI$1 = {
    targets: TargetsFunction;
    addExternalDependency: (ref: string) => void;
} & ConfigAPI;
type PluginAPI$1 = {
    assumption: AssumptionFunction;
} & PresetAPI$1;
declare function assertVersion(range: string | number): void;

interface UnloadedDescriptor<API, Options = {} | undefined | false> {
    name: string | undefined;
    value: object | ((api: API, options: Options, dirname: string) => unknown);
    options: Options;
    dirname: string;
    alias: string;
    ownPass?: boolean;
    file?: {
        request: string;
        resolved: string;
    };
}

/**
 * Create a config item using the same value format used in Babel's config
 * files. Items returned from this function should be cached by the caller
 * ideally, as recreating the config item will mean re-resolving the item
 * and re-evaluating the plugin/preset function.
 */
declare function createConfigItem$1<API>(value: PluginTarget | [PluginTarget, PluginOptions] | [PluginTarget, PluginOptions, string | void], { dirname, type, }?: {
    dirname?: string;
    type?: "preset" | "plugin";
}): Handler<ConfigItem<API>>;
declare const CONFIG_ITEM_BRAND: unique symbol;
/**
 * A public representation of a plugin/preset that will _eventually_ be load.
 * Users can use this to interact with the results of a loaded Babel
 * configuration.
 *
 * Any changes to public properties of this class should be considered a
 * breaking change to Babel's API.
 */
declare class ConfigItem<API> {
    /**
     * The private underlying descriptor that Babel actually cares about.
     * If you access this, you are a bad person.
     */
    _descriptor: UnloadedDescriptor<API>;
    /**
     * Used to detect ConfigItem instances from other Babel instances.
     */
    [CONFIG_ITEM_BRAND]: boolean;
    /**
     * The resolved value of the item itself.
     */
    value: {} | Function;
    /**
     * The options, if any, that were passed to the item.
     * Mutating this will lead to undefined behavior.
     *
     * "false" means that this item has been disabled.
     */
    options: {} | void | false;
    /**
     * The directory that the options for this item are relative to.
     */
    dirname: string;
    /**
     * Get the name of the plugin, if the user gave it one.
     */
    name: string | void;
    /**
     * Data about the file that the item was loaded from, if Babel knows it.
     */
    file: {
        request: string;
        resolved: string;
    } | void;
    constructor(descriptor: UnloadedDescriptor<API>);
}

type PluginObject<S extends PluginPass = PluginPass> = {
    name?: string;
    manipulateOptions?: (options: ValidatedOptions, parserOpts: ParserOptions) => void;
    pre?: (this: S, file: File) => void;
    post?: (this: S, file: File) => void;
    inherits?: (api: PluginAPI, options: unknown, dirname: string) => PluginObject;
    visitor?: Visitor<S>;
    parserOverride?: Function;
    generatorOverride?: Function;
};

declare class Plugin {
    key: string | undefined | null;
    manipulateOptions?: (options: unknown, parserOpts: unknown) => void;
    post?: PluginObject["post"];
    pre?: PluginObject["pre"];
    visitor: PluginObject["visitor"];
    parserOverride?: Function;
    generatorOverride?: Function;
    options: {};
    externalDependencies: ReadonlyDeepArray<string>;
    constructor(plugin: PluginObject, options: {}, key?: string, externalDependencies?: ReadonlyDeepArray<string>);
}

type InputOptions = ValidatedOptions;
type ValidatedOptions = {
    cwd?: string;
    filename?: string;
    filenameRelative?: string;
    babelrc?: boolean;
    babelrcRoots?: BabelrcSearch;
    configFile?: ConfigFileSearch;
    root?: string;
    rootMode?: RootMode;
    code?: boolean;
    ast?: boolean;
    cloneInputAst?: boolean;
    inputSourceMap?: RootInputSourceMapOption;
    envName?: string;
    caller?: CallerMetadata;
    extends?: string;
    env?: EnvSet<ValidatedOptions>;
    ignore?: IgnoreList;
    only?: IgnoreList;
    overrides?: OverridesList;
    test?: ConfigApplicableTest;
    include?: ConfigApplicableTest;
    exclude?: ConfigApplicableTest;
    presets?: PluginList;
    plugins?: PluginList;
    passPerPreset?: boolean;
    assumptions?: {
        [name: string]: boolean;
    };
    targets?: TargetsListOrObject;
    browserslistConfigFile?: ConfigFileSearch;
    browserslistEnv?: string;
    retainLines?: boolean;
    comments?: boolean;
    shouldPrintComment?: Function;
    compact?: CompactOption;
    minified?: boolean;
    auxiliaryCommentBefore?: string;
    auxiliaryCommentAfter?: string;
    sourceType?: SourceTypeOption;
    wrapPluginVisitorMethod?: Function;
    highlightCode?: boolean;
    sourceMaps?: SourceMapsOption;
    sourceMap?: SourceMapsOption;
    sourceFileName?: string;
    sourceRoot?: string;
    parserOpts?: ParserOptions;
    generatorOpts?: GeneratorOptions;
};
type NormalizedOptions = {
    readonly targets: Targets;
} & Omit<ValidatedOptions, "targets">;
type CallerMetadata = {
    name: string;
};
type EnvSet<T> = {
    [x: string]: T;
};
type IgnoreItem = string | RegExp | ((path: string | undefined, context: {
    dirname: string;
    caller: CallerMetadata;
    envName: string;
}) => unknown);
type IgnoreList = ReadonlyArray<IgnoreItem>;
type PluginOptions = object | void | false;
type PluginTarget = string | object | Function;
type PluginItem = ConfigItem<PluginAPI$1> | Plugin | PluginTarget | [PluginTarget, PluginOptions] | [PluginTarget, PluginOptions, string | void];
type PluginList = ReadonlyArray<PluginItem>;
type OverridesList = Array<ValidatedOptions>;
type ConfigApplicableTest = IgnoreItem | Array<IgnoreItem>;
type ConfigFileSearch = string | boolean;
type BabelrcSearch = boolean | IgnoreItem | IgnoreList;
type SourceMapsOption = boolean | "inline" | "both";
type SourceTypeOption = "module" | "script" | "unambiguous";
type CompactOption = boolean | "auto";
type RootInputSourceMapOption = {} | boolean;
type RootMode = "root" | "upward" | "upward-optional";
type TargetsListOrObject = Targets | InputTargets | InputTargets["browsers"];
declare const knownAssumptions: readonly ["arrayLikeIsIterable", "constantReexports", "constantSuper", "enumerableModuleMeta", "ignoreFunctionLength", "ignoreToPrimitiveHint", "iterableIsArray", "mutableTemplateObject", "noClassCalls", "noDocumentAll", "noIncompleteNsImportDetection", "noNewArrows", "noUninitializedPrivateFieldAccess", "objectRestNoSymbols", "privateFieldsAsSymbols", "privateFieldsAsProperties", "pureGetters", "setClassMethods", "setComputedProperties", "setPublicClassFields", "setSpreadProperties", "skipForOfIteratorClosing", "superIsCallableConstructor"];
type AssumptionName = (typeof knownAssumptions)[number];

type ResolvedConfig = {
    options: any;
    passes: PluginPasses;
    externalDependencies: ReadonlyDeepArray<string>;
};

type PluginPassList = Array<Plugin>;
type PluginPasses = Array<PluginPassList>;

type LoadPartialConfigOpts = {
    showIgnoredFiles?: boolean;
};
declare function loadPartialConfig$1(opts?: LoadPartialConfigOpts): Handler<PartialConfig | null>;

declare class PartialConfig {
    /**
     * These properties are public, so any changes to them should be considered
     * a breaking change to Babel's API.
     */
    options: NormalizedOptions;
    babelrc: string | void;
    babelignore: string | void;
    config: string | void;
    fileHandling: FileHandling;
    files: Set<string>;
    constructor(options: NormalizedOptions, babelrc: string | void, ignore: string | void, config: string | void, fileHandling: FileHandling, files: Set<string>);
    /**
     * Returns true if there is a config file in the filesystem for this config.
     */
    hasFilesystemConfig(): boolean;
}

type PluginAPI = PluginAPI$1 & typeof __;
type PresetAPI = PresetAPI$1 & typeof __;

declare const loadPartialConfigRunner: gensync.Gensync<[opts?: {
    showIgnoredFiles?: boolean;
}], PartialConfig, unknown>;
declare function loadPartialConfigAsync(...args: Parameters<typeof loadPartialConfigRunner.async>): Promise<PartialConfig>;
declare function loadPartialConfigSync(...args: Parameters<typeof loadPartialConfigRunner.sync>): PartialConfig;
declare function loadPartialConfig(opts: Parameters<typeof loadPartialConfig$1>[0], callback?: (err: Error, val: PartialConfig | null) => void): PartialConfig;
declare function loadOptionsImpl(opts: unknown): Handler<ResolvedConfig | null>;
declare const loadOptionsRunner: gensync.Gensync<[opts: unknown], ResolvedConfig, unknown>;
declare function loadOptionsAsync(...args: Parameters<typeof loadOptionsRunner.async>): Promise<ResolvedConfig>;
declare function loadOptionsSync(...args: Parameters<typeof loadOptionsRunner.sync>): ResolvedConfig;
declare function loadOptions(opts: Parameters<typeof loadOptionsImpl>[0], callback?: (err: Error, val: ResolvedConfig | null) => void): ResolvedConfig;
declare const createConfigItemRunner: gensync.Gensync<[value: PluginTarget | [PluginTarget, PluginOptions] | [PluginTarget, PluginOptions, string | void], {
    dirname?: string;
    type?: "preset" | "plugin";
}?], ConfigItem<unknown>, unknown>;
declare function createConfigItemAsync(...args: Parameters<typeof createConfigItemRunner.async>): Promise<ConfigItem<unknown>>;
declare function createConfigItemSync(...args: Parameters<typeof createConfigItemRunner.sync>): ConfigItem<unknown>;
declare function createConfigItem(target: PluginTarget, options: Parameters<typeof createConfigItem$1>[1], callback?: (err: Error, val: ConfigItem<PluginAPI> | null) => void): ConfigItem<unknown>;

type NormalizedFile = {
    code: string;
    ast: t.File;
    inputMap: SourceMapConverter | null;
};

declare class File {
    _map: Map<unknown, unknown>;
    opts: {
        [key: string]: any;
    };
    declarations: {
        [key: string]: t.Identifier;
    };
    path: NodePath<t.Program>;
    ast: t.File;
    scope: Scope;
    metadata: {
        [key: string]: any;
    };
    code: string;
    inputMap: any;
    hub: HubInterface & {
        file: File;
    };
    constructor(options: {}, { code, ast, inputMap }: NormalizedFile);
    /**
     * Provide backward-compatible access to the interpreter directive handling
     * in Babel 6.x. If you are writing a plugin for Babel 7.x, it would be
     * best to use 'program.interpreter' directly.
     */
    get shebang(): string;
    set shebang(value: string);
    set(key: unknown, val: unknown): void;
    get(key: unknown): any;
    has(key: unknown): boolean;
    getModuleName(): string | undefined | null;
    /**
     * Check if a given helper is available in @babel/core's helper list.
     *
     * This _also_ allows you to pass a Babel version specifically. If the
     * helper exists, but was not available for the full given range, it will be
     * considered unavailable.
     */
    availableHelper(name: string, versionRange?: string | null): boolean;
    addHelper(name: string): t.Identifier;
    buildCodeFrameError(node: t.Node | undefined | null, msg: string, _Error?: typeof Error): Error;
}

declare class PluginPass<Options = {}> {
    _map: Map<unknown, unknown>;
    key: string | undefined | null;
    file: File;
    opts: Partial<Options>;
    cwd: string;
    filename: string | void;
    constructor(file: File, key?: string | null, options?: Options);
    set(key: unknown, val: unknown): void;
    get(key: unknown): any;
    availableHelper(name: string, versionRange?: string | null): boolean;
    addHelper(name: string): t.Identifier;
    buildCodeFrameError(node: t.Node | undefined | null, msg: string, _Error?: typeof Error): Error;
}

declare function export_default(allowlist?: Array<string>, outputType?: "global" | "module" | "umd" | "var"): string;

declare function getEnv(defaultValue?: string): string;

type FileResultCallback = {
    (err: Error, file: null): void;
    (err: null, file: FileResult | null): void;
};
type FileResult = {
    metadata: {
        [key: string]: any;
    };
    options: {
        [key: string]: any;
    };
    ast: t.File | null;
    code: string | null;
    map: GeneratorResult["map"] | null;
    sourceType: "script" | "module";
    externalDependencies: Set<string>;
};

type Transform = {
    (code: string, callback: FileResultCallback): void;
    (code: string, opts: InputOptions | undefined | null, callback: FileResultCallback): void;
    (code: string, opts?: InputOptions | null): FileResult | null;
};
declare const transformRunner: gensync.Gensync<[code: string, opts?: ValidatedOptions], FileResult, unknown>;
declare const transform: Transform;
declare function transformSync(...args: Parameters<typeof transformRunner.sync>): FileResult;
declare function transformAsync(...args: Parameters<typeof transformRunner.async>): Promise<FileResult>;

declare const transformFileRunner: gensync.Gensync<[filename: string, opts?: ValidatedOptions], FileResult, unknown>;
declare function transformFile(filename: string, callback: FileResultCallback): void;
declare function transformFile(filename: string, opts: InputOptions | undefined | null, callback: FileResultCallback): void;
declare function transformFileSync(...args: Parameters<typeof transformFileRunner.sync>): FileResult;
declare function transformFileAsync(...args: Parameters<typeof transformFileRunner.async>): Promise<FileResult>;

type AstRoot = t.File | t.Program;
type TransformFromAst = {
    (ast: AstRoot, code: string, callback: FileResultCallback): void;
    (ast: AstRoot, code: string, opts: InputOptions | undefined | null, callback: FileResultCallback): void;
    (ast: AstRoot, code: string, opts?: InputOptions | null): FileResult | null;
};
declare const transformFromAstRunner: gensync.Gensync<[ast: AstRoot, code: string, opts: ValidatedOptions], FileResult, unknown>;
declare const transformFromAst: TransformFromAst;
declare function transformFromAstSync(...args: Parameters<typeof transformFromAstRunner.sync>): FileResult;
declare function transformFromAstAsync(...args: Parameters<typeof transformFromAstRunner.async>): Promise<FileResult>;

type FileParseCallback = {
    (err: Error, ast: null): void;
    (err: null, ast: File$1 | null): void;
};
type Parse = {
    (code: string, callback: FileParseCallback): void;
    (code: string, opts: InputOptions | undefined | null, callback: FileParseCallback): void;
    (code: string, opts?: InputOptions | null): File$1 | null;
};
declare const parseRunner: gensync.Gensync<[code: string, opts: ValidatedOptions], File$1, unknown>;
declare const parse: Parse;
declare function parseSync(...args: Parameters<typeof parseRunner.sync>): File$1;
declare function parseAsync(...args: Parameters<typeof parseRunner.async>): Promise<File$1>;

declare const version: string;

/**
 * Recommended set of compilable extensions. Not used in @babel/core directly, but meant as
 * as an easy source for tooling making use of @babel/core.
 */
declare const DEFAULT_EXTENSIONS: readonly [".js", ".jsx", ".es6", ".es", ".mjs", ".cjs"];

export { type CallerMetadata, ConfigItem, DEFAULT_EXTENSIONS, File, type FileResult, type InputOptions, type PluginAPI, type PluginObject, PluginPass, type PresetAPI, type ValidatedOptions as PresetObject, export_default as buildExternalHelpers, createConfigItem, createConfigItemAsync, createConfigItemSync, getEnv, loadOptions, loadOptionsAsync, loadOptionsSync, loadPartialConfig, loadPartialConfigAsync, loadPartialConfigSync, parse, parseAsync, parseSync, resolvePlugin, resolvePreset, transform, transformAsync, transformFile, transformFileAsync, transformFileSync, transformFromAst, transformFromAstAsync, transformFromAstSync, transformSync, version };

@babel/traverse

import * as t from '@babel/types';
import { Node, RemovePropertiesOptions } from '@babel/types';

type BindingKind = "var" | "let" | "const" | "module" | "hoisted" | "param" | "local" | "unknown";
/**
 * This class is responsible for a binding inside of a scope.
 *
 * It tracks the following:
 *
 *  * Node path.
 *  * Amount of times referenced by other nodes.
 *  * Paths to nodes that reassign or modify this binding.
 *  * The kind of binding. (Is it a parameter, declaration etc)
 */
declare class Binding {
    identifier: t.Identifier;
    scope: Scope;
    path: NodePath;
    kind: BindingKind;
    constructor({ identifier, scope, path, kind, }: {
        identifier: t.Identifier;
        scope: Scope;
        path: NodePath;
        kind: BindingKind;
    });
    constantViolations: Array<NodePath>;
    constant: boolean;
    referencePaths: Array<NodePath>;
    referenced: boolean;
    references: number;
    hasDeoptedValue: boolean;
    hasValue: boolean;
    value: any;
    deoptValue(): void;
    setValue(value: any): void;
    clearValue(): void;
    /**
     * Register a constant violation with the provided `path`.
     */
    reassign(path: NodePath): void;
    /**
     * Increment the amount of references to this binding.
     */
    reference(path: NodePath): void;
    /**
     * Decrement the amount of references to this binding.
     */
    dereference(): void;
}

declare class Scope {
    uid: number;
    path: NodePath;
    block: t.Pattern | t.Scopable;
    labels: Map<any, any>;
    inited: boolean;
    bindings: {
        [name: string]: Binding;
    };
    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<t.Pattern | t.Scopable>);
    /**
     * Globals.
     */
    static globals: string[];
    /**
     * Variables available in current context.
     */
    static contextVariables: string[];
    get parent(): Scope;
    get parentBlock(): t.Node;
    get hub(): HubInterface;
    traverse<S>(node: t.Node | t.Node[], opts: TraverseOptions<S>, state: S): void;
    traverse(node: t.Node | t.Node[], opts?: TraverseOptions, state?: any): void;
    /**
     * Generate a unique identifier and add it to the current scope.
     */
    generateDeclaredUidIdentifier(name?: string): t.Identifier;
    /**
     * Generate a unique identifier.
     */
    generateUidIdentifier(name?: string): t.Identifier;
    /**
     * Generate a unique `_id1` binding.
     */
    generateUid(name?: string): string;
    /**
     * Generate an `_id1`.
     */
    _generateUid(name: string, i: number): string;
    generateUidBasedOnNode(node: t.Node, defaultName?: string): string;
    /**
     * Generate a unique identifier based on a node.
     */
    generateUidIdentifierBasedOnNode(node: t.Node, defaultName?: string): t.Identifier;
    /**
     * Determine whether evaluating the specific input `node` is a consequenceless reference. ie.
     * evaluating it won't result in potentially arbitrary code from being ran. The following are
     * allowed and determined not to cause side effects:
     *
     *  - `this` expressions
     *  - `super` expressions
     *  - Bound identifiers
     */
    isStatic(node: t.Node): boolean;
    /**
     * Possibly generate a memoised identifier if it is not static and has consequences.
     */
    maybeGenerateMemoised(node: t.Node, dontPush?: boolean): t.Identifier;
    checkBlockScopedCollisions(local: Binding, kind: BindingKind, name: string, id: any): void;
    rename(oldName: string, newName?: string): void;
    /** @deprecated Not used in our codebase */
    _renameFromMap(map: Record<string | symbol, unknown>, oldName: string | symbol, newName: string | symbol, value: unknown): void;
    dump(): void;
    toArray(node: t.Node, i?: number | boolean, arrayLikeIsIterable?: boolean | void): t.ArrayExpression | t.CallExpression | t.Identifier;
    hasLabel(name: string): boolean;
    getLabel(name: string): any;
    registerLabel(path: NodePath<t.LabeledStatement>): void;
    registerDeclaration(path: NodePath): void;
    buildUndefinedNode(): t.UnaryExpression;
    registerConstantViolation(path: NodePath): void;
    registerBinding(kind: Binding["kind"], path: NodePath, bindingPath?: NodePath): void;
    addGlobal(node: t.Identifier | t.JSXIdentifier): void;
    hasUid(name: string): boolean;
    hasGlobal(name: string): boolean;
    hasReference(name: string): boolean;
    isPure(node: t.Node, constantsOnly?: boolean): boolean;
    /**
     * Set some arbitrary data on the current scope.
     */
    setData(key: string | symbol, val: any): any;
    /**
     * Recursively walk up scope tree looking for the data `key`.
     */
    getData(key: string | symbol): any;
    /**
     * Recursively walk up scope tree looking for the data `key` and if it exists,
     * remove it.
     */
    removeData(key: string): void;
    init(): void;
    crawl(): void;
    push(opts: {
        id: t.LVal;
        init?: t.Expression;
        unique?: boolean;
        _blockHoist?: number | undefined;
        kind?: "var" | "let" | "const";
    }): void;
    /**
     * Walk up to the top of the scope tree and get the `Program`.
     */
    getProgramParent(): Scope;
    /**
     * Walk up the scope tree until we hit either a Function or return null.
     */
    getFunctionParent(): Scope | null;
    /**
     * Walk up the scope tree until we hit either a BlockStatement/Loop/Program/Function/Switch or reach the
     * very top and hit Program.
     */
    getBlockParent(): Scope;
    /**
     * Walk up from a pattern scope (function param initializer) until we hit a non-pattern scope,
     * then returns its block parent
     * @returns An ancestry scope whose path is a block parent
     */
    getPatternParent(): Scope;
    /**
     * Walks the scope tree and gathers **all** bindings.
     */
    getAllBindings(): Record<string, Binding>;
    /**
     * Walks the scope tree and gathers all declarations of `kind`.
     */
    getAllBindingsOfKind(...kinds: string[]): Record<string, Binding>;
    bindingIdentifierEquals(name: string, node: t.Node): boolean;
    getBinding(name: string): Binding | undefined;
    getOwnBinding(name: string): Binding | undefined;
    getBindingIdentifier(name: string): t.Identifier;
    getOwnBindingIdentifier(name: string): t.Identifier;
    hasOwnBinding(name: string): boolean;
    hasBinding(name: string, opts?: boolean | {
        noGlobals?: boolean;
        noUids?: boolean;
    }): boolean;
    parentHasBinding(name: string, opts?: {
        noGlobals?: boolean;
        noUids?: boolean;
    }): boolean;
    /**
     * Move a binding of `name` to another `scope`.
     */
    moveBindingTo(name: string, scope: Scope): void;
    removeOwnBinding(name: string): void;
    removeBinding(name: string): void;
}

interface HubInterface {
    getCode(): string | void;
    getScope(): Scope | void;
    addHelper(name: string): any;
    buildError(node: Node, msg: string, Error: new () => Error): Error;
}
declare class Hub implements HubInterface {
    getCode(): void;
    getScope(): void;
    addHelper(): void;
    buildError(node: Node, msg: string, Error?: TypeErrorConstructor): Error;
}

declare class TraversalContext<S = unknown> {
    constructor(scope: Scope, opts: ExplodedTraverseOptions<S>, state: S, parentPath: NodePath);
    parentPath: NodePath;
    scope: Scope;
    state: S;
    opts: ExplodedTraverseOptions<S>;
    queue: Array<NodePath> | null;
    priorityQueue: Array<NodePath> | null;
    /**
     * This method does a simple check to determine whether or not we really need to attempt
     * visit a node. This will prevent us from constructing a NodePath.
     */
    shouldVisit(node: t.Node): boolean;
    create(node: t.Node, container: t.Node | t.Node[], key: string | number, listKey?: string): NodePath;
    maybeQueue(path: NodePath, notPriority?: boolean): void;
    visitMultiple(container: t.Node[], parent: t.Node, listKey: string): boolean;
    visitSingle(node: t.Node, key: string): boolean;
    visitQueue(queue: Array<NodePath>): boolean;
    visit(node: t.Node, key: string): boolean;
}

interface VirtualTypeAliases {
    BindingIdentifier: t.Identifier;
    BlockScoped: t.Node;
    ExistentialTypeParam: t.ExistsTypeAnnotation;
    Expression: t.Expression;
    Flow: t.Flow | t.ImportDeclaration | t.ExportDeclaration | t.ImportSpecifier;
    ForAwaitStatement: t.ForOfStatement;
    Generated: t.Node;
    NumericLiteralTypeAnnotation: t.NumberLiteralTypeAnnotation;
    Pure: t.Node;
    Referenced: t.Node;
    ReferencedIdentifier: t.Identifier | t.JSXIdentifier;
    ReferencedMemberExpression: t.MemberExpression;
    RestProperty: t.RestElement;
    Scope: t.Scopable | t.Pattern;
    SpreadProperty: t.RestElement;
    Statement: t.Statement;
    User: t.Node;
    Var: t.VariableDeclaration;
}

type VisitPhase = "enter" | "exit";
type VisitNodeObject<S, P extends t.Node> = {
    [K in VisitPhase]?: VisitNodeFunction<S, P>;
};
type ExplVisitNode<S, P extends t.Node> = {
    [K in VisitPhase]?: VisitNodeFunction<S, P>[];
};
type ExplodedVisitor<S = unknown> = ExplVisitNode<S, t.Node> & {
    [Type in t.Node["type"]]?: ExplVisitNode<S, Extract<t.Node, {
        type: Type;
    }>>;
} & {
    _exploded: true;
    _verified: true;
};
type Visitor<S = unknown> = (VisitNodeObject<S, t.Node> & {
    [Type in t.Node["type"]]?: VisitNode<S, Extract<t.Node, {
        type: Type;
    }>>;
} & {
    [K in keyof t.Aliases]?: VisitNode<S, t.Aliases[K]>;
} & {
    [K in keyof VirtualTypeAliases]?: VisitNode<S, VirtualTypeAliases[K]>;
} & {
    [k: `${string}|${string}`]: VisitNode<S, t.Node>;
}) | ExplodedVisitor<S>;
type VisitNode<S, P extends t.Node> = VisitNodeFunction<S, P> | VisitNodeObject<S, P>;
type VisitNodeFunction<S, P extends t.Node> = (this: S, path: NodePath<P>, state: S) => void;

/**
 * Starting at the parent path of the current `NodePath` and going up the
 * tree, return the first `NodePath` that causes the provided `callback`
 * to return a truthy value, or `null` if the `callback` never returns a
 * truthy value.
 */
declare function findParent(this: NodePath, callback: (path: NodePath) => boolean): NodePath | null;
/**
 * Starting at current `NodePath` and going up the tree, return the first
 * `NodePath` that causes the provided `callback` to return a truthy value,
 * or `null` if the `callback` never returns a truthy value.
 */
declare function find(this: NodePath, callback: (path: NodePath) => boolean): NodePath | null;
/**
 * Get the parent function of the current path.
 */
declare function getFunctionParent(this: NodePath): NodePath<t.Function> | null;
/**
 * Walk up the tree until we hit a parent node path in a list.
 */
declare function getStatementParent(this: NodePath): NodePath<t.Statement>;
/**
 * Get the deepest common ancestor and then from it, get the earliest relationship path
 * to that ancestor.
 *
 * Earliest is defined as being "before" all the other nodes in terms of list container
 * position and visiting key.
 */
declare function getEarliestCommonAncestorFrom(this: NodePath, paths: Array<NodePath>): NodePath;
/**
 * Get the earliest path in the tree where the provided `paths` intersect.
 *
 * TODO: Possible optimisation target.
 */
declare function getDeepestCommonAncestorFrom(this: NodePath, paths: Array<NodePath>, filter?: (deepest: NodePath, i: number, ancestries: NodePath[][]) => NodePath): NodePath;
/**
 * Build an array of node paths containing the entire ancestry of the current node path.
 *
 * NOTE: The current node path is included in this.
 */
declare function getAncestry(this: NodePath): Array<NodePath>;
/**
 * A helper to find if `this` path is an ancestor of @param maybeDescendant
 */
declare function isAncestor(this: NodePath, maybeDescendant: NodePath): boolean;
/**
 * A helper to find if `this` path is a descendant of @param maybeAncestor
 */
declare function isDescendant(this: NodePath, maybeAncestor: NodePath): boolean;
declare function inType(this: NodePath, ...candidateTypes: string[]): boolean;

declare const NodePath_ancestry_find: typeof find;
declare const NodePath_ancestry_findParent: typeof findParent;
declare const NodePath_ancestry_getAncestry: typeof getAncestry;
declare const NodePath_ancestry_getDeepestCommonAncestorFrom: typeof getDeepestCommonAncestorFrom;
declare const NodePath_ancestry_getEarliestCommonAncestorFrom: typeof getEarliestCommonAncestorFrom;
declare const NodePath_ancestry_getFunctionParent: typeof getFunctionParent;
declare const NodePath_ancestry_getStatementParent: typeof getStatementParent;
declare const NodePath_ancestry_inType: typeof inType;
declare const NodePath_ancestry_isAncestor: typeof isAncestor;
declare const NodePath_ancestry_isDescendant: typeof isDescendant;
declare namespace NodePath_ancestry {
  export { NodePath_ancestry_find as find, NodePath_ancestry_findParent as findParent, NodePath_ancestry_getAncestry as getAncestry, NodePath_ancestry_getDeepestCommonAncestorFrom as getDeepestCommonAncestorFrom, NodePath_ancestry_getEarliestCommonAncestorFrom as getEarliestCommonAncestorFrom, NodePath_ancestry_getFunctionParent as getFunctionParent, NodePath_ancestry_getStatementParent as getStatementParent, NodePath_ancestry_inType as inType, NodePath_ancestry_isAncestor as isAncestor, NodePath_ancestry_isDescendant as isDescendant };
}

/**
 * Infer the type of the current `NodePath`.
 */
declare function getTypeAnnotation(this: NodePath): t.FlowType | t.TSType;
/**
 * todo: split up this method
 */
declare function _getTypeAnnotation(this: NodePath): any;
declare function isBaseType(this: NodePath, baseName: string, soft?: boolean): boolean;
declare function couldBeBaseType(this: NodePath, name: string): boolean;
declare function baseTypeStrictlyMatches(this: NodePath, rightArg: NodePath): boolean;
declare function isGenericType(this: NodePath, genericName: string): boolean;

declare const NodePath_inference__getTypeAnnotation: typeof _getTypeAnnotation;
declare const NodePath_inference_baseTypeStrictlyMatches: typeof baseTypeStrictlyMatches;
declare const NodePath_inference_couldBeBaseType: typeof couldBeBaseType;
declare const NodePath_inference_getTypeAnnotation: typeof getTypeAnnotation;
declare const NodePath_inference_isBaseType: typeof isBaseType;
declare const NodePath_inference_isGenericType: typeof isGenericType;
declare namespace NodePath_inference {
  export { NodePath_inference__getTypeAnnotation as _getTypeAnnotation, NodePath_inference_baseTypeStrictlyMatches as baseTypeStrictlyMatches, NodePath_inference_couldBeBaseType as couldBeBaseType, NodePath_inference_getTypeAnnotation as getTypeAnnotation, NodePath_inference_isBaseType as isBaseType, NodePath_inference_isGenericType as isGenericType };
}

/**
 * Replace a node with an array of multiple. This method performs the following steps:
 *
 *  - Inherit the comments of first provided node with that of the current node.
 *  - Insert the provided nodes after the current node.
 *  - Remove the current node.
 */
declare function replaceWithMultiple(this: NodePath, nodes: t.Node | t.Node[]): NodePath[];
/**
 * Parse a string as an expression and replace the current node with the result.
 *
 * NOTE: This is typically not a good idea to use. Building source strings when
 * transforming ASTs is an antipattern and SHOULD NOT be encouraged. Even if it's
 * easier to use, your transforms will be extremely brittle.
 */
declare function replaceWithSourceString(this: NodePath, replacement: string): [NodePath<t.ArrayExpression | t.ArrowFunctionExpression | t.AssignmentExpression | t.AwaitExpression | t.BigIntLiteral | t.BinaryExpression | t.BindExpression | t.BooleanLiteral | t.CallExpression | t.ClassExpression | t.ConditionalExpression | t.DecimalLiteral | t.DoExpression | t.FunctionExpression | t.Identifier | t.Import | t.ImportExpression | t.JSXElement | t.JSXFragment | t.LogicalExpression | t.MemberExpression | t.MetaProperty | t.ModuleExpression | t.NewExpression | t.NullLiteral | t.NumericLiteral | t.ObjectExpression | t.OptionalCallExpression | t.OptionalMemberExpression | t.ParenthesizedExpression | t.PipelineBareFunction | t.PipelinePrimaryTopicReference | t.PipelineTopicExpression | t.RecordExpression | t.RegExpLiteral | t.SequenceExpression | t.StringLiteral | t.Super | t.TSAsExpression | t.TSInstantiationExpression | t.TSNonNullExpression | t.TSSatisfiesExpression | t.TSTypeAssertion | t.TaggedTemplateExpression | t.TemplateLiteral | t.ThisExpression | t.TopicReference | t.TupleExpression | t.TypeCastExpression | t.UnaryExpression | t.UpdateExpression | t.YieldExpression>];
/**
 * Replace the current node with another.
 */
declare function replaceWith<R extends t.Node>(this: NodePath, replacementPath: R | NodePath<R>): [NodePath<R>];
/**
 * Description
 */
declare function _replaceWith(this: NodePath, node: t.Node): void;
/**
 * This method takes an array of statements nodes and then explodes it
 * into expressions. This method retains completion records which is
 * extremely important to retain original semantics.
 */
declare function replaceExpressionWithStatements(this: NodePath, nodes: Array<t.Statement>): NodePath<t.Statement>[];
declare function replaceInline(this: NodePath, nodes: t.Node | Array<t.Node>): NodePath<t.Node>[];

declare const NodePath_replacement__replaceWith: typeof _replaceWith;
declare const NodePath_replacement_replaceExpressionWithStatements: typeof replaceExpressionWithStatements;
declare const NodePath_replacement_replaceInline: typeof replaceInline;
declare const NodePath_replacement_replaceWith: typeof replaceWith;
declare const NodePath_replacement_replaceWithMultiple: typeof replaceWithMultiple;
declare const NodePath_replacement_replaceWithSourceString: typeof replaceWithSourceString;
declare namespace NodePath_replacement {
  export { NodePath_replacement__replaceWith as _replaceWith, NodePath_replacement_replaceExpressionWithStatements as replaceExpressionWithStatements, NodePath_replacement_replaceInline as replaceInline, NodePath_replacement_replaceWith as replaceWith, NodePath_replacement_replaceWithMultiple as replaceWithMultiple, NodePath_replacement_replaceWithSourceString as replaceWithSourceString };
}

/**
 * Walk the input `node` and statically evaluate if it's truthy.
 *
 * Returning `true` when we're sure that the expression will evaluate to a
 * truthy value, `false` if we're sure that it will evaluate to a falsy
 * value and `undefined` if we aren't sure. Because of this please do not
 * rely on coercion when using this method and check with === if it's false.
 *
 * For example do:
 *
 *   if (t.evaluateTruthy(node) === false) falsyLogic();
 *
 * **AND NOT**
 *
 *   if (!t.evaluateTruthy(node)) falsyLogic();
 *
 */
declare function evaluateTruthy(this: NodePath): boolean;
/**
 * Walk the input `node` and statically evaluate it.
 *
 * Returns an object in the form `{ confident, value, deopt }`. `confident`
 * indicates whether or not we had to drop out of evaluating the expression
 * because of hitting an unknown node that we couldn't confidently find the
 * value of, in which case `deopt` is the path of said node.
 *
 * Example:
 *
 *   t.evaluate(parse("5 + 5")) // { confident: true, value: 10 }
 *   t.evaluate(parse("!true")) // { confident: true, value: false }
 *   t.evaluate(parse("foo + foo")) // { confident: false, value: undefined, deopt: NodePath }
 *
 */
declare function evaluate(this: NodePath): {
    confident: boolean;
    value: any;
    deopt?: NodePath;
};

declare const NodePath_evaluation_evaluate: typeof evaluate;
declare const NodePath_evaluation_evaluateTruthy: typeof evaluateTruthy;
declare namespace NodePath_evaluation {
  export { NodePath_evaluation_evaluate as evaluate, NodePath_evaluation_evaluateTruthy as evaluateTruthy };
}

declare function toComputedKey(this: NodePath): t.PrivateName | t.Expression;
declare function ensureBlock(this: NodePath<t.Loop | t.WithStatement | t.Function | t.LabeledStatement | t.CatchClause>): t.ArrayExpression | t.ArrowFunctionExpression | t.AssignmentExpression | t.AwaitExpression | t.BigIntLiteral | t.BinaryExpression | t.BindExpression | t.BlockStatement | t.BooleanLiteral | t.BreakStatement | t.CallExpression | t.CatchClause | t.ClassDeclaration | t.ClassExpression | t.ClassMethod | t.ClassPrivateMethod | t.ConditionalExpression | t.ContinueStatement | t.DebuggerStatement | t.DecimalLiteral | t.DeclareClass | t.DeclareExportAllDeclaration | t.DeclareExportDeclaration | t.DeclareFunction | t.DeclareInterface | t.DeclareModule | t.DeclareModuleExports | t.DeclareOpaqueType | t.DeclareTypeAlias | t.DeclareVariable | t.DoExpression | t.DoWhileStatement | t.EmptyStatement | t.EnumDeclaration | t.ExportAllDeclaration | t.ExportDefaultDeclaration | t.ExportNamedDeclaration | t.ExpressionStatement | t.ForInStatement | t.ForOfStatement | t.ForStatement | t.FunctionDeclaration | t.FunctionExpression | t.Identifier | t.IfStatement | t.Import | t.ImportDeclaration | t.ImportExpression | t.InterfaceDeclaration | t.JSXElement | t.JSXFragment | t.LabeledStatement | t.LogicalExpression | t.MemberExpression | t.MetaProperty | t.ModuleExpression | t.NewExpression | t.NullLiteral | t.NumericLiteral | t.ObjectExpression | t.ObjectMethod | t.OpaqueType | t.OptionalCallExpression | t.OptionalMemberExpression | t.ParenthesizedExpression | t.PipelineBareFunction | t.PipelinePrimaryTopicReference | t.PipelineTopicExpression | t.RecordExpression | t.RegExpLiteral | t.ReturnStatement | t.SequenceExpression | t.StringLiteral | t.Super | t.SwitchStatement | t.TSAsExpression | t.TSDeclareFunction | t.TSEnumDeclaration | t.TSExportAssignment | t.TSImportEqualsDeclaration | t.TSInstantiationExpression | t.TSInterfaceDeclaration | t.TSModuleDeclaration | t.TSNamespaceExportDeclaration | t.TSNonNullExpression | t.TSSatisfiesExpression | t.TSTypeAliasDeclaration | t.TSTypeAssertion | t.TaggedTemplateExpression | t.TemplateLiteral | t.ThisExpression | t.ThrowStatement | t.TopicReference | t.TryStatement | t.TupleExpression | t.TypeAlias | t.TypeCastExpression | t.UnaryExpression | t.UpdateExpression | t.VariableDeclaration | t.WhileStatement | t.WithStatement | t.YieldExpression;
/**
 * Given an arbitrary function, process its content as if it were an arrow function, moving references
 * to "this", "arguments", "super", and such into the function's parent scope. This method is useful if
 * you have wrapped some set of items in an IIFE or other function, but want "this", "arguments", and super"
 * to continue behaving as expected.
 */
declare function unwrapFunctionEnvironment(this: NodePath): void;
/**
 * Convert a given arrow function into a normal ES5 function expression.
 */
declare function arrowFunctionToExpression(this: NodePath<t.ArrowFunctionExpression>, { allowInsertArrow, allowInsertArrowWithRest, noNewArrows, }?: {
    allowInsertArrow?: boolean | void;
    allowInsertArrowWithRest?: boolean | void;
    noNewArrows?: boolean;
}): NodePath<Exclude<t.Function, t.Method | t.ArrowFunctionExpression> | t.CallExpression>;

declare const NodePath_conversion_arrowFunctionToExpression: typeof arrowFunctionToExpression;
declare const NodePath_conversion_ensureBlock: typeof ensureBlock;
declare const NodePath_conversion_toComputedKey: typeof toComputedKey;
declare const NodePath_conversion_unwrapFunctionEnvironment: typeof unwrapFunctionEnvironment;
declare namespace NodePath_conversion {
  export { NodePath_conversion_arrowFunctionToExpression as arrowFunctionToExpression, NodePath_conversion_ensureBlock as ensureBlock, NodePath_conversion_toComputedKey as toComputedKey, NodePath_conversion_unwrapFunctionEnvironment as unwrapFunctionEnvironment };
}

/**
 * Match the current node if it matches the provided `pattern`.
 *
 * For example, given the match `React.createClass` it would match the
 * parsed nodes of `React.createClass` and `React["createClass"]`.
 */
declare function matchesPattern(this: NodePath, pattern: string, allowPartial?: boolean): boolean;
/**
 * Check whether we have the input `key`. If the `key` references an array then we check
 * if the array has any items, otherwise we just check if it's falsy.
 */
declare function has<N extends t.Node>(this: NodePath<N>, key: keyof N): boolean;
/**
 * Description
 */
declare function isStatic(this: NodePath): boolean;
/**
 * Alias of `has`.
 */
declare const is: typeof has;
/**
 * Opposite of `has`.
 */
declare function isnt<N extends t.Node>(this: NodePath<N>, key: keyof N): boolean;
/**
 * Check whether the path node `key` strict equals `value`.
 */
declare function equals<N extends t.Node>(this: NodePath<N>, key: keyof N, value: any): boolean;
/**
 * Check the type against our stored internal type of the node. This is handy when a node has
 * been removed yet we still internally know the type and need it to calculate node replacement.
 */
declare function isNodeType(this: NodePath, type: string): boolean;
/**
 * This checks whether or not we're in one of the following positions:
 *
 *   for (KEY in right);
 *   for (KEY;;);
 *
 * This is because these spots allow VariableDeclarations AND normal expressions so we need
 * to tell the path replacement that it's ok to replace this with an expression.
 */
declare function canHaveVariableDeclarationOrExpression(this: NodePath): boolean;
/**
 * This checks whether we are swapping an arrow function's body between an
 * expression and a block statement (or vice versa).
 *
 * This is because arrow functions may implicitly return an expression, which
 * is the same as containing a block statement.
 */
declare function canSwapBetweenExpressionAndStatement(this: NodePath, replacement: t.Node): boolean;
/**
 * Check whether the current path references a completion record
 */
declare function isCompletionRecord(this: NodePath, allowInsideFunction?: boolean): boolean;
/**
 * Check whether or not the current `key` allows either a single statement or block statement
 * so we can explode it if necessary.
 */
declare function isStatementOrBlock(this: NodePath): boolean;
/**
 * Check if the currently assigned path references the `importName` of `moduleSource`.
 */
declare function referencesImport(this: NodePath, moduleSource: string, importName: string): boolean;
/**
 * Get the source code associated with this node.
 */
declare function getSource(this: NodePath): string;
declare function willIMaybeExecuteBefore(this: NodePath, target: NodePath): boolean;
type RelativeExecutionStatus = "before" | "after" | "unknown";
/**
 * Given a `target` check the execution status of it relative to the current path.
 *
 * "Execution status" simply refers to where or not we **think** this will execute
 * before or after the input `target` element.
 */
declare function _guessExecutionStatusRelativeTo(this: NodePath, target: NodePath): RelativeExecutionStatus;
/**
 * Resolve a "pointer" `NodePath` to it's absolute path.
 */
declare function resolve(this: NodePath, dangerous?: boolean, resolved?: NodePath[]): NodePath<t.Node>;
declare function _resolve(this: NodePath, dangerous?: boolean, resolved?: NodePath[]): NodePath | undefined | null;
declare function isConstantExpression(this: NodePath): boolean;
declare function isInStrictMode(this: NodePath): boolean;

declare const NodePath_introspection__guessExecutionStatusRelativeTo: typeof _guessExecutionStatusRelativeTo;
declare const NodePath_introspection__resolve: typeof _resolve;
declare const NodePath_introspection_canHaveVariableDeclarationOrExpression: typeof canHaveVariableDeclarationOrExpression;
declare const NodePath_introspection_canSwapBetweenExpressionAndStatement: typeof canSwapBetweenExpressionAndStatement;
declare const NodePath_introspection_equals: typeof equals;
declare const NodePath_introspection_getSource: typeof getSource;
declare const NodePath_introspection_has: typeof has;
declare const NodePath_introspection_is: typeof is;
declare const NodePath_introspection_isCompletionRecord: typeof isCompletionRecord;
declare const NodePath_introspection_isConstantExpression: typeof isConstantExpression;
declare const NodePath_introspection_isInStrictMode: typeof isInStrictMode;
declare const NodePath_introspection_isNodeType: typeof isNodeType;
declare const NodePath_introspection_isStatementOrBlock: typeof isStatementOrBlock;
declare const NodePath_introspection_isStatic: typeof isStatic;
declare const NodePath_introspection_isnt: typeof isnt;
declare const NodePath_introspection_matchesPattern: typeof matchesPattern;
declare const NodePath_introspection_referencesImport: typeof referencesImport;
declare const NodePath_introspection_resolve: typeof resolve;
declare const NodePath_introspection_willIMaybeExecuteBefore: typeof willIMaybeExecuteBefore;
declare namespace NodePath_introspection {
  export { NodePath_introspection__guessExecutionStatusRelativeTo as _guessExecutionStatusRelativeTo, NodePath_introspection__resolve as _resolve, NodePath_introspection_canHaveVariableDeclarationOrExpression as canHaveVariableDeclarationOrExpression, NodePath_introspection_canSwapBetweenExpressionAndStatement as canSwapBetweenExpressionAndStatement, NodePath_introspection_equals as equals, NodePath_introspection_getSource as getSource, NodePath_introspection_has as has, NodePath_introspection_is as is, NodePath_introspection_isCompletionRecord as isCompletionRecord, NodePath_introspection_isConstantExpression as isConstantExpression, NodePath_introspection_isInStrictMode as isInStrictMode, NodePath_introspection_isNodeType as isNodeType, NodePath_introspection_isStatementOrBlock as isStatementOrBlock, NodePath_introspection_isStatic as isStatic, NodePath_introspection_isnt as isnt, NodePath_introspection_matchesPattern as matchesPattern, NodePath_introspection_referencesImport as referencesImport, NodePath_introspection_resolve as resolve, NodePath_introspection_willIMaybeExecuteBefore as willIMaybeExecuteBefore };
}

declare function call(this: NodePath, key: VisitPhase): boolean;
declare function _call(this: NodePath, fns?: Array<Function>): boolean;
declare function isDenylisted(this: NodePath): boolean;

declare function visit(this: NodePath): boolean;
declare function skip(this: NodePath): void;
declare function skipKey(this: NodePath, key: string): void;
declare function stop(this: NodePath): void;
declare function setScope(this: NodePath): void;
declare function setContext<S = unknown>(this: NodePath, context?: TraversalContext<S>): NodePath<t.Node>;
/**
 * Here we resync the node paths `key` and `container`. If they've changed according
 * to what we have stored internally then we attempt to resync by crawling and looking
 * for the new values.
 */
declare function resync(this: NodePath): void;
declare function _resyncParent(this: NodePath): void;
declare function _resyncKey(this: NodePath): void;
declare function _resyncList(this: NodePath): void;
declare function _resyncRemoved(this: NodePath): void;
declare function popContext(this: NodePath): void;
declare function pushContext(this: NodePath, context: TraversalContext): void;
declare function setup(this: NodePath, parentPath: NodePath | undefined, container: t.Node | t.Node[], listKey: string, key: string | number): void;
declare function setKey(this: NodePath, key: string | number): void;
declare function requeue(this: NodePath, pathToQueue?: NodePath<t.Node>): void;
declare function _getQueueContexts(this: NodePath): TraversalContext<unknown>[];

declare const NodePath_context__call: typeof _call;
declare const NodePath_context__getQueueContexts: typeof _getQueueContexts;
declare const NodePath_context__resyncKey: typeof _resyncKey;
declare const NodePath_context__resyncList: typeof _resyncList;
declare const NodePath_context__resyncParent: typeof _resyncParent;
declare const NodePath_context__resyncRemoved: typeof _resyncRemoved;
declare const NodePath_context_call: typeof call;
declare const NodePath_context_isDenylisted: typeof isDenylisted;
declare const NodePath_context_popContext: typeof popContext;
declare const NodePath_context_pushContext: typeof pushContext;
declare const NodePath_context_requeue: typeof requeue;
declare const NodePath_context_resync: typeof resync;
declare const NodePath_context_setContext: typeof setContext;
declare const NodePath_context_setKey: typeof setKey;
declare const NodePath_context_setScope: typeof setScope;
declare const NodePath_context_setup: typeof setup;
declare const NodePath_context_skip: typeof skip;
declare const NodePath_context_skipKey: typeof skipKey;
declare const NodePath_context_stop: typeof stop;
declare const NodePath_context_visit: typeof visit;
declare namespace NodePath_context {
  export { NodePath_context__call as _call, NodePath_context__getQueueContexts as _getQueueContexts, NodePath_context__resyncKey as _resyncKey, NodePath_context__resyncList as _resyncList, NodePath_context__resyncParent as _resyncParent, NodePath_context__resyncRemoved as _resyncRemoved, NodePath_context_call as call, isDenylisted as isBlacklisted, NodePath_context_isDenylisted as isDenylisted, NodePath_context_popContext as popContext, NodePath_context_pushContext as pushContext, NodePath_context_requeue as requeue, NodePath_context_resync as resync, NodePath_context_setContext as setContext, NodePath_context_setKey as setKey, NodePath_context_setScope as setScope, NodePath_context_setup as setup, NodePath_context_skip as skip, NodePath_context_skipKey as skipKey, NodePath_context_stop as stop, NodePath_context_visit as visit };
}

declare function remove(this: NodePath): void;
declare function _removeFromScope(this: NodePath): void;
declare function _callRemovalHooks(this: NodePath): boolean;
declare function _remove(this: NodePath): void;
declare function _markRemoved(this: NodePath): void;
declare function _assertUnremoved(this: NodePath): void;

declare const NodePath_removal__assertUnremoved: typeof _assertUnremoved;
declare const NodePath_removal__callRemovalHooks: typeof _callRemovalHooks;
declare const NodePath_removal__markRemoved: typeof _markRemoved;
declare const NodePath_removal__remove: typeof _remove;
declare const NodePath_removal__removeFromScope: typeof _removeFromScope;
declare const NodePath_removal_remove: typeof remove;
declare namespace NodePath_removal {
  export { NodePath_removal__assertUnremoved as _assertUnremoved, NodePath_removal__callRemovalHooks as _callRemovalHooks, NodePath_removal__markRemoved as _markRemoved, NodePath_removal__remove as _remove, NodePath_removal__removeFromScope as _removeFromScope, NodePath_removal_remove as remove };
}

/**
 * Insert the provided nodes before the current one.
 */
declare function insertBefore(this: NodePath, nodes_: t.Node | t.Node[]): NodePath[];
declare function _containerInsert<N extends t.Node>(this: NodePath, from: number, nodes: N[]): NodePath<N>[];
declare function _containerInsertBefore<N extends t.Node>(this: NodePath, nodes: N[]): NodePath<N>[];
declare function _containerInsertAfter<N extends t.Node>(this: NodePath, nodes: N[]): NodePath<N>[];
/**
 * Insert the provided nodes after the current one. When inserting nodes after an
 * expression, ensure that the completion record is correct by pushing the current node.
 */
declare function insertAfter(this: NodePath, nodes_: t.Node | t.Node[]): NodePath[];
/**
 * Update all sibling node paths after `fromIndex` by `incrementBy`.
 */
declare function updateSiblingKeys(this: NodePath, fromIndex: number, incrementBy: number): void;
declare function _verifyNodeList<N extends t.Node>(this: NodePath, nodes: N | N[]): N[];
declare function unshiftContainer<N extends t.Node, K extends keyof N & string>(this: NodePath<N>, listKey: K, nodes: N[K] extends (infer E)[] ? E | E[] : never): NodePath<t.Node>[];
declare function pushContainer<N extends t.Node, K extends keyof N & string>(this: NodePath<N>, listKey: K, nodes: N[K] extends (infer E)[] ? E | E[] : never): NodePath<t.Node>[];
/**
 * Hoist the current node to the highest scope possible and return a UID
 * referencing it.
 */
declare function hoist<T extends t.Node>(this: NodePath<T>, scope?: Scope): NodePath<t.Expression>;

declare const NodePath_modification__containerInsert: typeof _containerInsert;
declare const NodePath_modification__containerInsertAfter: typeof _containerInsertAfter;
declare const NodePath_modification__containerInsertBefore: typeof _containerInsertBefore;
declare const NodePath_modification__verifyNodeList: typeof _verifyNodeList;
declare const NodePath_modification_hoist: typeof hoist;
declare const NodePath_modification_insertAfter: typeof insertAfter;
declare const NodePath_modification_insertBefore: typeof insertBefore;
declare const NodePath_modification_pushContainer: typeof pushContainer;
declare const NodePath_modification_unshiftContainer: typeof unshiftContainer;
declare const NodePath_modification_updateSiblingKeys: typeof updateSiblingKeys;
declare namespace NodePath_modification {
  export { NodePath_modification__containerInsert as _containerInsert, NodePath_modification__containerInsertAfter as _containerInsertAfter, NodePath_modification__containerInsertBefore as _containerInsertBefore, NodePath_modification__verifyNodeList as _verifyNodeList, NodePath_modification_hoist as hoist, NodePath_modification_insertAfter as insertAfter, NodePath_modification_insertBefore as insertBefore, NodePath_modification_pushContainer as pushContainer, NodePath_modification_unshiftContainer as unshiftContainer, NodePath_modification_updateSiblingKeys as updateSiblingKeys };
}

declare function getOpposite(this: NodePath): NodePath | null;
/**
 * Retrieve the completion records of a given path.
 * Note: to ensure proper support on `break` statement, this method
 * will manipulate the AST around the break statement. Do not call the method
 * twice for the same path.
 *
 * @export
 * @param {NodePath} this
 * @returns {NodePath[]} Completion records
 */
declare function getCompletionRecords(this: NodePath): NodePath[];
declare function getSibling(this: NodePath, key: string | number): NodePath;
declare function getPrevSibling(this: NodePath): NodePath;
declare function getNextSibling(this: NodePath): NodePath;
declare function getAllNextSiblings(this: NodePath): NodePath[];
declare function getAllPrevSiblings(this: NodePath): NodePath[];
type MaybeToIndex<T extends string> = T extends `${bigint}` ? number : T;
type Pattern<Obj extends string, Prop extends string> = `${Obj}.${Prop}`;
type Split<P extends string> = P extends Pattern<infer O, infer U> ? [MaybeToIndex<O>, ...Split<U>] : [MaybeToIndex<P>];
type NodeKeyOf<Node extends t.Node | t.Node[]> = keyof Pick<Node, {
    [Key in keyof Node]-?: Node[Key] extends t.Node | t.Node[] ? Key : never;
}[keyof Node]>;
type Trav<Node extends t.Node | t.Node[], Path extends unknown[]> = Path extends [infer K, ...infer R] ? K extends NodeKeyOf<Node> ? R extends [] ? Node[K] : Trav<Node[K], R> : never : never;
type ToNodePath<T> = T extends Array<t.Node | null | undefined> ? Array<NodePath<T[number]>> : T extends t.Node | null | undefined ? NodePath<T> : never;
declare function get<T extends t.Node, K extends keyof T>(this: NodePath<T>, key: K, context?: boolean | TraversalContext): T[K] extends Array<t.Node | null | undefined> ? Array<NodePath<T[K][number]>> : T[K] extends t.Node | null | undefined ? NodePath<T[K]> : never;
declare function get<T extends t.Node, K extends string>(this: NodePath<T>, key: K, context?: boolean | TraversalContext): ToNodePath<Trav<T, Split<K>>>;
declare function get<T extends t.Node>(this: NodePath<T>, key: string, context?: true | TraversalContext): NodePath | NodePath[];

declare function _getKey<T extends t.Node>(this: NodePath<T>, key: keyof T & string, context?: TraversalContext): NodePath | NodePath[];
declare function _getPattern(this: NodePath, parts: string[], context?: TraversalContext): NodePath | NodePath[];
declare function getBindingIdentifiers(duplicates: true): Record<string, t.Identifier[]>;
declare function getBindingIdentifiers(duplicates?: false): Record<string, t.Identifier>;
declare function getBindingIdentifiers(duplicates: boolean): Record<string, t.Identifier[] | t.Identifier>;

declare function getOuterBindingIdentifiers(duplicates: true): Record<string, t.Identifier[]>;
declare function getOuterBindingIdentifiers(duplicates?: false): Record<string, t.Identifier>;
declare function getOuterBindingIdentifiers(duplicates: boolean): Record<string, t.Identifier[] | t.Identifier>;

declare function getBindingIdentifierPaths(duplicates: true, outerOnly?: boolean): Record<string, NodePath<t.Identifier>[]>;
declare function getBindingIdentifierPaths(duplicates: false, outerOnly?: boolean): Record<string, NodePath<t.Identifier>>;
declare function getBindingIdentifierPaths(duplicates?: boolean, outerOnly?: boolean): Record<string, NodePath<t.Identifier> | NodePath<t.Identifier>[]>;

declare function getOuterBindingIdentifierPaths(duplicates: true): Record<string, NodePath<t.Identifier>[]>;
declare function getOuterBindingIdentifierPaths(duplicates?: false): Record<string, NodePath<t.Identifier>>;
declare function getOuterBindingIdentifierPaths(duplicates?: boolean): Record<string, NodePath<t.Identifier> | NodePath<t.Identifier>[]>;

declare const NodePath_family__getKey: typeof _getKey;
declare const NodePath_family__getPattern: typeof _getPattern;
declare const NodePath_family_get: typeof get;
declare const NodePath_family_getAllNextSiblings: typeof getAllNextSiblings;
declare const NodePath_family_getAllPrevSiblings: typeof getAllPrevSiblings;
declare const NodePath_family_getBindingIdentifierPaths: typeof getBindingIdentifierPaths;
declare const NodePath_family_getBindingIdentifiers: typeof getBindingIdentifiers;
declare const NodePath_family_getCompletionRecords: typeof getCompletionRecords;
declare const NodePath_family_getNextSibling: typeof getNextSibling;
declare const NodePath_family_getOpposite: typeof getOpposite;
declare const NodePath_family_getOuterBindingIdentifierPaths: typeof getOuterBindingIdentifierPaths;
declare const NodePath_family_getOuterBindingIdentifiers: typeof getOuterBindingIdentifiers;
declare const NodePath_family_getPrevSibling: typeof getPrevSibling;
declare const NodePath_family_getSibling: typeof getSibling;
declare namespace NodePath_family {
  export { NodePath_family__getKey as _getKey, NodePath_family__getPattern as _getPattern, NodePath_family_get as get, NodePath_family_getAllNextSiblings as getAllNextSiblings, NodePath_family_getAllPrevSiblings as getAllPrevSiblings, NodePath_family_getBindingIdentifierPaths as getBindingIdentifierPaths, NodePath_family_getBindingIdentifiers as getBindingIdentifiers, NodePath_family_getCompletionRecords as getCompletionRecords, NodePath_family_getNextSibling as getNextSibling, NodePath_family_getOpposite as getOpposite, NodePath_family_getOuterBindingIdentifierPaths as getOuterBindingIdentifierPaths, NodePath_family_getOuterBindingIdentifiers as getOuterBindingIdentifiers, NodePath_family_getPrevSibling as getPrevSibling, NodePath_family_getSibling as getSibling };
}

/**
 * Share comments amongst siblings.
 */
declare function shareCommentsWithSiblings(this: NodePath): void;
declare function addComment(this: NodePath, type: t.CommentTypeShorthand, content: string, line?: boolean): void;
/**
 * Give node `comments` of the specified `type`.
 */
declare function addComments(this: NodePath, type: t.CommentTypeShorthand, comments: t.Comment[]): void;

declare const NodePath_comments_addComment: typeof addComment;
declare const NodePath_comments_addComments: typeof addComments;
declare const NodePath_comments_shareCommentsWithSiblings: typeof shareCommentsWithSiblings;
declare namespace NodePath_comments {
  export { NodePath_comments_addComment as addComment, NodePath_comments_addComments as addComments, NodePath_comments_shareCommentsWithSiblings as shareCommentsWithSiblings };
}

/*
 * This file is auto-generated! Do not modify it directly.
 * To re-generate run 'make build'
 */


type Opts$2<Obj> = Partial<{
  [Prop in keyof Obj]: Obj[Prop] extends t.Node
    ? t.Node
    : Obj[Prop] extends t.Node[]
      ? t.Node[]
      : Obj[Prop];
}>;

interface NodePathAssertions {
  assertAccessor(opts?: Opts$2<t.Accessor>): asserts this is NodePath<t.Accessor>;
  assertAnyTypeAnnotation(
    opts?: Opts$2<t.AnyTypeAnnotation>,
  ): asserts this is NodePath<t.AnyTypeAnnotation>;
  assertArgumentPlaceholder(
    opts?: Opts$2<t.ArgumentPlaceholder>,
  ): asserts this is NodePath<t.ArgumentPlaceholder>;
  assertArrayExpression(
    opts?: Opts$2<t.ArrayExpression>,
  ): asserts this is NodePath<t.ArrayExpression>;
  assertArrayPattern(
    opts?: Opts$2<t.ArrayPattern>,
  ): asserts this is NodePath<t.ArrayPattern>;
  assertArrayTypeAnnotation(
    opts?: Opts$2<t.ArrayTypeAnnotation>,
  ): asserts this is NodePath<t.ArrayTypeAnnotation>;
  assertArrowFunctionExpression(
    opts?: Opts$2<t.ArrowFunctionExpression>,
  ): asserts this is NodePath<t.ArrowFunctionExpression>;
  assertAssignmentExpression(
    opts?: Opts$2<t.AssignmentExpression>,
  ): asserts this is NodePath<t.AssignmentExpression>;
  assertAssignmentPattern(
    opts?: Opts$2<t.AssignmentPattern>,
  ): asserts this is NodePath<t.AssignmentPattern>;
  assertAwaitExpression(
    opts?: Opts$2<t.AwaitExpression>,
  ): asserts this is NodePath<t.AwaitExpression>;
  assertBigIntLiteral(
    opts?: Opts$2<t.BigIntLiteral>,
  ): asserts this is NodePath<t.BigIntLiteral>;
  assertBinary(opts?: Opts$2<t.Binary>): asserts this is NodePath<t.Binary>;
  assertBinaryExpression(
    opts?: Opts$2<t.BinaryExpression>,
  ): asserts this is NodePath<t.BinaryExpression>;
  assertBindExpression(
    opts?: Opts$2<t.BindExpression>,
  ): asserts this is NodePath<t.BindExpression>;
  assertBlock(opts?: Opts$2<t.Block>): asserts this is NodePath<t.Block>;
  assertBlockParent(
    opts?: Opts$2<t.BlockParent>,
  ): asserts this is NodePath<t.BlockParent>;
  assertBlockStatement(
    opts?: Opts$2<t.BlockStatement>,
  ): asserts this is NodePath<t.BlockStatement>;
  assertBooleanLiteral(
    opts?: Opts$2<t.BooleanLiteral>,
  ): asserts this is NodePath<t.BooleanLiteral>;
  assertBooleanLiteralTypeAnnotation(
    opts?: Opts$2<t.BooleanLiteralTypeAnnotation>,
  ): asserts this is NodePath<t.BooleanLiteralTypeAnnotation>;
  assertBooleanTypeAnnotation(
    opts?: Opts$2<t.BooleanTypeAnnotation>,
  ): asserts this is NodePath<t.BooleanTypeAnnotation>;
  assertBreakStatement(
    opts?: Opts$2<t.BreakStatement>,
  ): asserts this is NodePath<t.BreakStatement>;
  assertCallExpression(
    opts?: Opts$2<t.CallExpression>,
  ): asserts this is NodePath<t.CallExpression>;
  assertCatchClause(
    opts?: Opts$2<t.CatchClause>,
  ): asserts this is NodePath<t.CatchClause>;
  assertClass(opts?: Opts$2<t.Class>): asserts this is NodePath<t.Class>;
  assertClassAccessorProperty(
    opts?: Opts$2<t.ClassAccessorProperty>,
  ): asserts this is NodePath<t.ClassAccessorProperty>;
  assertClassBody(
    opts?: Opts$2<t.ClassBody>,
  ): asserts this is NodePath<t.ClassBody>;
  assertClassDeclaration(
    opts?: Opts$2<t.ClassDeclaration>,
  ): asserts this is NodePath<t.ClassDeclaration>;
  assertClassExpression(
    opts?: Opts$2<t.ClassExpression>,
  ): asserts this is NodePath<t.ClassExpression>;
  assertClassImplements(
    opts?: Opts$2<t.ClassImplements>,
  ): asserts this is NodePath<t.ClassImplements>;
  assertClassMethod(
    opts?: Opts$2<t.ClassMethod>,
  ): asserts this is NodePath<t.ClassMethod>;
  assertClassPrivateMethod(
    opts?: Opts$2<t.ClassPrivateMethod>,
  ): asserts this is NodePath<t.ClassPrivateMethod>;
  assertClassPrivateProperty(
    opts?: Opts$2<t.ClassPrivateProperty>,
  ): asserts this is NodePath<t.ClassPrivateProperty>;
  assertClassProperty(
    opts?: Opts$2<t.ClassProperty>,
  ): asserts this is NodePath<t.ClassProperty>;
  assertCompletionStatement(
    opts?: Opts$2<t.CompletionStatement>,
  ): asserts this is NodePath<t.CompletionStatement>;
  assertConditional(
    opts?: Opts$2<t.Conditional>,
  ): asserts this is NodePath<t.Conditional>;
  assertConditionalExpression(
    opts?: Opts$2<t.ConditionalExpression>,
  ): asserts this is NodePath<t.ConditionalExpression>;
  assertContinueStatement(
    opts?: Opts$2<t.ContinueStatement>,
  ): asserts this is NodePath<t.ContinueStatement>;
  assertDebuggerStatement(
    opts?: Opts$2<t.DebuggerStatement>,
  ): asserts this is NodePath<t.DebuggerStatement>;
  assertDecimalLiteral(
    opts?: Opts$2<t.DecimalLiteral>,
  ): asserts this is NodePath<t.DecimalLiteral>;
  assertDeclaration(
    opts?: Opts$2<t.Declaration>,
  ): asserts this is NodePath<t.Declaration>;
  assertDeclareClass(
    opts?: Opts$2<t.DeclareClass>,
  ): asserts this is NodePath<t.DeclareClass>;
  assertDeclareExportAllDeclaration(
    opts?: Opts$2<t.DeclareExportAllDeclaration>,
  ): asserts this is NodePath<t.DeclareExportAllDeclaration>;
  assertDeclareExportDeclaration(
    opts?: Opts$2<t.DeclareExportDeclaration>,
  ): asserts this is NodePath<t.DeclareExportDeclaration>;
  assertDeclareFunction(
    opts?: Opts$2<t.DeclareFunction>,
  ): asserts this is NodePath<t.DeclareFunction>;
  assertDeclareInterface(
    opts?: Opts$2<t.DeclareInterface>,
  ): asserts this is NodePath<t.DeclareInterface>;
  assertDeclareModule(
    opts?: Opts$2<t.DeclareModule>,
  ): asserts this is NodePath<t.DeclareModule>;
  assertDeclareModuleExports(
    opts?: Opts$2<t.DeclareModuleExports>,
  ): asserts this is NodePath<t.DeclareModuleExports>;
  assertDeclareOpaqueType(
    opts?: Opts$2<t.DeclareOpaqueType>,
  ): asserts this is NodePath<t.DeclareOpaqueType>;
  assertDeclareTypeAlias(
    opts?: Opts$2<t.DeclareTypeAlias>,
  ): asserts this is NodePath<t.DeclareTypeAlias>;
  assertDeclareVariable(
    opts?: Opts$2<t.DeclareVariable>,
  ): asserts this is NodePath<t.DeclareVariable>;
  assertDeclaredPredicate(
    opts?: Opts$2<t.DeclaredPredicate>,
  ): asserts this is NodePath<t.DeclaredPredicate>;
  assertDecorator(
    opts?: Opts$2<t.Decorator>,
  ): asserts this is NodePath<t.Decorator>;
  assertDirective(
    opts?: Opts$2<t.Directive>,
  ): asserts this is NodePath<t.Directive>;
  assertDirectiveLiteral(
    opts?: Opts$2<t.DirectiveLiteral>,
  ): asserts this is NodePath<t.DirectiveLiteral>;
  assertDoExpression(
    opts?: Opts$2<t.DoExpression>,
  ): asserts this is NodePath<t.DoExpression>;
  assertDoWhileStatement(
    opts?: Opts$2<t.DoWhileStatement>,
  ): asserts this is NodePath<t.DoWhileStatement>;
  assertEmptyStatement(
    opts?: Opts$2<t.EmptyStatement>,
  ): asserts this is NodePath<t.EmptyStatement>;
  assertEmptyTypeAnnotation(
    opts?: Opts$2<t.EmptyTypeAnnotation>,
  ): asserts this is NodePath<t.EmptyTypeAnnotation>;
  assertEnumBody(opts?: Opts$2<t.EnumBody>): asserts this is NodePath<t.EnumBody>;
  assertEnumBooleanBody(
    opts?: Opts$2<t.EnumBooleanBody>,
  ): asserts this is NodePath<t.EnumBooleanBody>;
  assertEnumBooleanMember(
    opts?: Opts$2<t.EnumBooleanMember>,
  ): asserts this is NodePath<t.EnumBooleanMember>;
  assertEnumDeclaration(
    opts?: Opts$2<t.EnumDeclaration>,
  ): asserts this is NodePath<t.EnumDeclaration>;
  assertEnumDefaultedMember(
    opts?: Opts$2<t.EnumDefaultedMember>,
  ): asserts this is NodePath<t.EnumDefaultedMember>;
  assertEnumMember(
    opts?: Opts$2<t.EnumMember>,
  ): asserts this is NodePath<t.EnumMember>;
  assertEnumNumberBody(
    opts?: Opts$2<t.EnumNumberBody>,
  ): asserts this is NodePath<t.EnumNumberBody>;
  assertEnumNumberMember(
    opts?: Opts$2<t.EnumNumberMember>,
  ): asserts this is NodePath<t.EnumNumberMember>;
  assertEnumStringBody(
    opts?: Opts$2<t.EnumStringBody>,
  ): asserts this is NodePath<t.EnumStringBody>;
  assertEnumStringMember(
    opts?: Opts$2<t.EnumStringMember>,
  ): asserts this is NodePath<t.EnumStringMember>;
  assertEnumSymbolBody(
    opts?: Opts$2<t.EnumSymbolBody>,
  ): asserts this is NodePath<t.EnumSymbolBody>;
  assertExistsTypeAnnotation(
    opts?: Opts$2<t.ExistsTypeAnnotation>,
  ): asserts this is NodePath<t.ExistsTypeAnnotation>;
  assertExportAllDeclaration(
    opts?: Opts$2<t.ExportAllDeclaration>,
  ): asserts this is NodePath<t.ExportAllDeclaration>;
  assertExportDeclaration(
    opts?: Opts$2<t.ExportDeclaration>,
  ): asserts this is NodePath<t.ExportDeclaration>;
  assertExportDefaultDeclaration(
    opts?: Opts$2<t.ExportDefaultDeclaration>,
  ): asserts this is NodePath<t.ExportDefaultDeclaration>;
  assertExportDefaultSpecifier(
    opts?: Opts$2<t.ExportDefaultSpecifier>,
  ): asserts this is NodePath<t.ExportDefaultSpecifier>;
  assertExportNamedDeclaration(
    opts?: Opts$2<t.ExportNamedDeclaration>,
  ): asserts this is NodePath<t.ExportNamedDeclaration>;
  assertExportNamespaceSpecifier(
    opts?: Opts$2<t.ExportNamespaceSpecifier>,
  ): asserts this is NodePath<t.ExportNamespaceSpecifier>;
  assertExportSpecifier(
    opts?: Opts$2<t.ExportSpecifier>,
  ): asserts this is NodePath<t.ExportSpecifier>;
  assertExpression(
    opts?: Opts$2<t.Expression>,
  ): asserts this is NodePath<t.Expression>;
  assertExpressionStatement(
    opts?: Opts$2<t.ExpressionStatement>,
  ): asserts this is NodePath<t.ExpressionStatement>;
  assertExpressionWrapper(
    opts?: Opts$2<t.ExpressionWrapper>,
  ): asserts this is NodePath<t.ExpressionWrapper>;
  assertFile(opts?: Opts$2<t.File>): asserts this is NodePath<t.File>;
  assertFlow(opts?: Opts$2<t.Flow>): asserts this is NodePath<t.Flow>;
  assertFlowBaseAnnotation(
    opts?: Opts$2<t.FlowBaseAnnotation>,
  ): asserts this is NodePath<t.FlowBaseAnnotation>;
  assertFlowDeclaration(
    opts?: Opts$2<t.FlowDeclaration>,
  ): asserts this is NodePath<t.FlowDeclaration>;
  assertFlowPredicate(
    opts?: Opts$2<t.FlowPredicate>,
  ): asserts this is NodePath<t.FlowPredicate>;
  assertFlowType(opts?: Opts$2<t.FlowType>): asserts this is NodePath<t.FlowType>;
  assertFor(opts?: Opts$2<t.For>): asserts this is NodePath<t.For>;
  assertForInStatement(
    opts?: Opts$2<t.ForInStatement>,
  ): asserts this is NodePath<t.ForInStatement>;
  assertForOfStatement(
    opts?: Opts$2<t.ForOfStatement>,
  ): asserts this is NodePath<t.ForOfStatement>;
  assertForStatement(
    opts?: Opts$2<t.ForStatement>,
  ): asserts this is NodePath<t.ForStatement>;
  assertForXStatement(
    opts?: Opts$2<t.ForXStatement>,
  ): asserts this is NodePath<t.ForXStatement>;
  assertFunction(opts?: Opts$2<t.Function>): asserts this is NodePath<t.Function>;
  assertFunctionDeclaration(
    opts?: Opts$2<t.FunctionDeclaration>,
  ): asserts this is NodePath<t.FunctionDeclaration>;
  assertFunctionExpression(
    opts?: Opts$2<t.FunctionExpression>,
  ): asserts this is NodePath<t.FunctionExpression>;
  assertFunctionParent(
    opts?: Opts$2<t.FunctionParent>,
  ): asserts this is NodePath<t.FunctionParent>;
  assertFunctionTypeAnnotation(
    opts?: Opts$2<t.FunctionTypeAnnotation>,
  ): asserts this is NodePath<t.FunctionTypeAnnotation>;
  assertFunctionTypeParam(
    opts?: Opts$2<t.FunctionTypeParam>,
  ): asserts this is NodePath<t.FunctionTypeParam>;
  assertGenericTypeAnnotation(
    opts?: Opts$2<t.GenericTypeAnnotation>,
  ): asserts this is NodePath<t.GenericTypeAnnotation>;
  assertIdentifier(
    opts?: Opts$2<t.Identifier>,
  ): asserts this is NodePath<t.Identifier>;
  assertIfStatement(
    opts?: Opts$2<t.IfStatement>,
  ): asserts this is NodePath<t.IfStatement>;
  assertImmutable(
    opts?: Opts$2<t.Immutable>,
  ): asserts this is NodePath<t.Immutable>;
  assertImport(opts?: Opts$2<t.Import>): asserts this is NodePath<t.Import>;
  assertImportAttribute(
    opts?: Opts$2<t.ImportAttribute>,
  ): asserts this is NodePath<t.ImportAttribute>;
  assertImportDeclaration(
    opts?: Opts$2<t.ImportDeclaration>,
  ): asserts this is NodePath<t.ImportDeclaration>;
  assertImportDefaultSpecifier(
    opts?: Opts$2<t.ImportDefaultSpecifier>,
  ): asserts this is NodePath<t.ImportDefaultSpecifier>;
  assertImportExpression(
    opts?: Opts$2<t.ImportExpression>,
  ): asserts this is NodePath<t.ImportExpression>;
  assertImportNamespaceSpecifier(
    opts?: Opts$2<t.ImportNamespaceSpecifier>,
  ): asserts this is NodePath<t.ImportNamespaceSpecifier>;
  assertImportOrExportDeclaration(
    opts?: Opts$2<t.ImportOrExportDeclaration>,
  ): asserts this is NodePath<t.ImportOrExportDeclaration>;
  assertImportSpecifier(
    opts?: Opts$2<t.ImportSpecifier>,
  ): asserts this is NodePath<t.ImportSpecifier>;
  assertIndexedAccessType(
    opts?: Opts$2<t.IndexedAccessType>,
  ): asserts this is NodePath<t.IndexedAccessType>;
  assertInferredPredicate(
    opts?: Opts$2<t.InferredPredicate>,
  ): asserts this is NodePath<t.InferredPredicate>;
  assertInterfaceDeclaration(
    opts?: Opts$2<t.InterfaceDeclaration>,
  ): asserts this is NodePath<t.InterfaceDeclaration>;
  assertInterfaceExtends(
    opts?: Opts$2<t.InterfaceExtends>,
  ): asserts this is NodePath<t.InterfaceExtends>;
  assertInterfaceTypeAnnotation(
    opts?: Opts$2<t.InterfaceTypeAnnotation>,
  ): asserts this is NodePath<t.InterfaceTypeAnnotation>;
  assertInterpreterDirective(
    opts?: Opts$2<t.InterpreterDirective>,
  ): asserts this is NodePath<t.InterpreterDirective>;
  assertIntersectionTypeAnnotation(
    opts?: Opts$2<t.IntersectionTypeAnnotation>,
  ): asserts this is NodePath<t.IntersectionTypeAnnotation>;
  assertJSX(opts?: Opts$2<t.JSX>): asserts this is NodePath<t.JSX>;
  assertJSXAttribute(
    opts?: Opts$2<t.JSXAttribute>,
  ): asserts this is NodePath<t.JSXAttribute>;
  assertJSXClosingElement(
    opts?: Opts$2<t.JSXClosingElement>,
  ): asserts this is NodePath<t.JSXClosingElement>;
  assertJSXClosingFragment(
    opts?: Opts$2<t.JSXClosingFragment>,
  ): asserts this is NodePath<t.JSXClosingFragment>;
  assertJSXElement(
    opts?: Opts$2<t.JSXElement>,
  ): asserts this is NodePath<t.JSXElement>;
  assertJSXEmptyExpression(
    opts?: Opts$2<t.JSXEmptyExpression>,
  ): asserts this is NodePath<t.JSXEmptyExpression>;
  assertJSXExpressionContainer(
    opts?: Opts$2<t.JSXExpressionContainer>,
  ): asserts this is NodePath<t.JSXExpressionContainer>;
  assertJSXFragment(
    opts?: Opts$2<t.JSXFragment>,
  ): asserts this is NodePath<t.JSXFragment>;
  assertJSXIdentifier(
    opts?: Opts$2<t.JSXIdentifier>,
  ): asserts this is NodePath<t.JSXIdentifier>;
  assertJSXMemberExpression(
    opts?: Opts$2<t.JSXMemberExpression>,
  ): asserts this is NodePath<t.JSXMemberExpression>;
  assertJSXNamespacedName(
    opts?: Opts$2<t.JSXNamespacedName>,
  ): asserts this is NodePath<t.JSXNamespacedName>;
  assertJSXOpeningElement(
    opts?: Opts$2<t.JSXOpeningElement>,
  ): asserts this is NodePath<t.JSXOpeningElement>;
  assertJSXOpeningFragment(
    opts?: Opts$2<t.JSXOpeningFragment>,
  ): asserts this is NodePath<t.JSXOpeningFragment>;
  assertJSXSpreadAttribute(
    opts?: Opts$2<t.JSXSpreadAttribute>,
  ): asserts this is NodePath<t.JSXSpreadAttribute>;
  assertJSXSpreadChild(
    opts?: Opts$2<t.JSXSpreadChild>,
  ): asserts this is NodePath<t.JSXSpreadChild>;
  assertJSXText(opts?: Opts$2<t.JSXText>): asserts this is NodePath<t.JSXText>;
  assertLVal(opts?: Opts$2<t.LVal>): asserts this is NodePath<t.LVal>;
  assertLabeledStatement(
    opts?: Opts$2<t.LabeledStatement>,
  ): asserts this is NodePath<t.LabeledStatement>;
  assertLiteral(opts?: Opts$2<t.Literal>): asserts this is NodePath<t.Literal>;
  assertLogicalExpression(
    opts?: Opts$2<t.LogicalExpression>,
  ): asserts this is NodePath<t.LogicalExpression>;
  assertLoop(opts?: Opts$2<t.Loop>): asserts this is NodePath<t.Loop>;
  assertMemberExpression(
    opts?: Opts$2<t.MemberExpression>,
  ): asserts this is NodePath<t.MemberExpression>;
  assertMetaProperty(
    opts?: Opts$2<t.MetaProperty>,
  ): asserts this is NodePath<t.MetaProperty>;
  assertMethod(opts?: Opts$2<t.Method>): asserts this is NodePath<t.Method>;
  assertMiscellaneous(
    opts?: Opts$2<t.Miscellaneous>,
  ): asserts this is NodePath<t.Miscellaneous>;
  assertMixedTypeAnnotation(
    opts?: Opts$2<t.MixedTypeAnnotation>,
  ): asserts this is NodePath<t.MixedTypeAnnotation>;
  assertModuleDeclaration(
    opts?: Opts$2<t.ModuleDeclaration>,
  ): asserts this is NodePath<t.ModuleDeclaration>;
  assertModuleExpression(
    opts?: Opts$2<t.ModuleExpression>,
  ): asserts this is NodePath<t.ModuleExpression>;
  assertModuleSpecifier(
    opts?: Opts$2<t.ModuleSpecifier>,
  ): asserts this is NodePath<t.ModuleSpecifier>;
  assertNewExpression(
    opts?: Opts$2<t.NewExpression>,
  ): asserts this is NodePath<t.NewExpression>;
  assertNoop(opts?: Opts$2<t.Noop>): asserts this is NodePath<t.Noop>;
  assertNullLiteral(
    opts?: Opts$2<t.NullLiteral>,
  ): asserts this is NodePath<t.NullLiteral>;
  assertNullLiteralTypeAnnotation(
    opts?: Opts$2<t.NullLiteralTypeAnnotation>,
  ): asserts this is NodePath<t.NullLiteralTypeAnnotation>;
  assertNullableTypeAnnotation(
    opts?: Opts$2<t.NullableTypeAnnotation>,
  ): asserts this is NodePath<t.NullableTypeAnnotation>;
  assertNumberLiteral(
    opts?: Opts$2<t.NumberLiteral>,
  ): asserts this is NodePath<t.NumberLiteral>;
  assertNumberLiteralTypeAnnotation(
    opts?: Opts$2<t.NumberLiteralTypeAnnotation>,
  ): asserts this is NodePath<t.NumberLiteralTypeAnnotation>;
  assertNumberTypeAnnotation(
    opts?: Opts$2<t.NumberTypeAnnotation>,
  ): asserts this is NodePath<t.NumberTypeAnnotation>;
  assertNumericLiteral(
    opts?: Opts$2<t.NumericLiteral>,
  ): asserts this is NodePath<t.NumericLiteral>;
  assertObjectExpression(
    opts?: Opts$2<t.ObjectExpression>,
  ): asserts this is NodePath<t.ObjectExpression>;
  assertObjectMember(
    opts?: Opts$2<t.ObjectMember>,
  ): asserts this is NodePath<t.ObjectMember>;
  assertObjectMethod(
    opts?: Opts$2<t.ObjectMethod>,
  ): asserts this is NodePath<t.ObjectMethod>;
  assertObjectPattern(
    opts?: Opts$2<t.ObjectPattern>,
  ): asserts this is NodePath<t.ObjectPattern>;
  assertObjectProperty(
    opts?: Opts$2<t.ObjectProperty>,
  ): asserts this is NodePath<t.ObjectProperty>;
  assertObjectTypeAnnotation(
    opts?: Opts$2<t.ObjectTypeAnnotation>,
  ): asserts this is NodePath<t.ObjectTypeAnnotation>;
  assertObjectTypeCallProperty(
    opts?: Opts$2<t.ObjectTypeCallProperty>,
  ): asserts this is NodePath<t.ObjectTypeCallProperty>;
  assertObjectTypeIndexer(
    opts?: Opts$2<t.ObjectTypeIndexer>,
  ): asserts this is NodePath<t.ObjectTypeIndexer>;
  assertObjectTypeInternalSlot(
    opts?: Opts$2<t.ObjectTypeInternalSlot>,
  ): asserts this is NodePath<t.ObjectTypeInternalSlot>;
  assertObjectTypeProperty(
    opts?: Opts$2<t.ObjectTypeProperty>,
  ): asserts this is NodePath<t.ObjectTypeProperty>;
  assertObjectTypeSpreadProperty(
    opts?: Opts$2<t.ObjectTypeSpreadProperty>,
  ): asserts this is NodePath<t.ObjectTypeSpreadProperty>;
  assertOpaqueType(
    opts?: Opts$2<t.OpaqueType>,
  ): asserts this is NodePath<t.OpaqueType>;
  assertOptionalCallExpression(
    opts?: Opts$2<t.OptionalCallExpression>,
  ): asserts this is NodePath<t.OptionalCallExpression>;
  assertOptionalIndexedAccessType(
    opts?: Opts$2<t.OptionalIndexedAccessType>,
  ): asserts this is NodePath<t.OptionalIndexedAccessType>;
  assertOptionalMemberExpression(
    opts?: Opts$2<t.OptionalMemberExpression>,
  ): asserts this is NodePath<t.OptionalMemberExpression>;
  assertParenthesizedExpression(
    opts?: Opts$2<t.ParenthesizedExpression>,
  ): asserts this is NodePath<t.ParenthesizedExpression>;
  assertPattern(opts?: Opts$2<t.Pattern>): asserts this is NodePath<t.Pattern>;
  assertPatternLike(
    opts?: Opts$2<t.PatternLike>,
  ): asserts this is NodePath<t.PatternLike>;
  assertPipelineBareFunction(
    opts?: Opts$2<t.PipelineBareFunction>,
  ): asserts this is NodePath<t.PipelineBareFunction>;
  assertPipelinePrimaryTopicReference(
    opts?: Opts$2<t.PipelinePrimaryTopicReference>,
  ): asserts this is NodePath<t.PipelinePrimaryTopicReference>;
  assertPipelineTopicExpression(
    opts?: Opts$2<t.PipelineTopicExpression>,
  ): asserts this is NodePath<t.PipelineTopicExpression>;
  assertPlaceholder(
    opts?: Opts$2<t.Placeholder>,
  ): asserts this is NodePath<t.Placeholder>;
  assertPrivate(opts?: Opts$2<t.Private>): asserts this is NodePath<t.Private>;
  assertPrivateName(
    opts?: Opts$2<t.PrivateName>,
  ): asserts this is NodePath<t.PrivateName>;
  assertProgram(opts?: Opts$2<t.Program>): asserts this is NodePath<t.Program>;
  assertProperty(opts?: Opts$2<t.Property>): asserts this is NodePath<t.Property>;
  assertPureish(opts?: Opts$2<t.Pureish>): asserts this is NodePath<t.Pureish>;
  assertQualifiedTypeIdentifier(
    opts?: Opts$2<t.QualifiedTypeIdentifier>,
  ): asserts this is NodePath<t.QualifiedTypeIdentifier>;
  assertRecordExpression(
    opts?: Opts$2<t.RecordExpression>,
  ): asserts this is NodePath<t.RecordExpression>;
  assertRegExpLiteral(
    opts?: Opts$2<t.RegExpLiteral>,
  ): asserts this is NodePath<t.RegExpLiteral>;
  assertRegexLiteral(
    opts?: Opts$2<t.RegexLiteral>,
  ): asserts this is NodePath<t.RegexLiteral>;
  assertRestElement(
    opts?: Opts$2<t.RestElement>,
  ): asserts this is NodePath<t.RestElement>;
  assertRestProperty(
    opts?: Opts$2<t.RestProperty>,
  ): asserts this is NodePath<t.RestProperty>;
  assertReturnStatement(
    opts?: Opts$2<t.ReturnStatement>,
  ): asserts this is NodePath<t.ReturnStatement>;
  assertScopable(opts?: Opts$2<t.Scopable>): asserts this is NodePath<t.Scopable>;
  assertSequenceExpression(
    opts?: Opts$2<t.SequenceExpression>,
  ): asserts this is NodePath<t.SequenceExpression>;
  assertSpreadElement(
    opts?: Opts$2<t.SpreadElement>,
  ): asserts this is NodePath<t.SpreadElement>;
  assertSpreadProperty(
    opts?: Opts$2<t.SpreadProperty>,
  ): asserts this is NodePath<t.SpreadProperty>;
  assertStandardized(
    opts?: Opts$2<t.Standardized>,
  ): asserts this is NodePath<t.Standardized>;
  assertStatement(
    opts?: Opts$2<t.Statement>,
  ): asserts this is NodePath<t.Statement>;
  assertStaticBlock(
    opts?: Opts$2<t.StaticBlock>,
  ): asserts this is NodePath<t.StaticBlock>;
  assertStringLiteral(
    opts?: Opts$2<t.StringLiteral>,
  ): asserts this is NodePath<t.StringLiteral>;
  assertStringLiteralTypeAnnotation(
    opts?: Opts$2<t.StringLiteralTypeAnnotation>,
  ): asserts this is NodePath<t.StringLiteralTypeAnnotation>;
  assertStringTypeAnnotation(
    opts?: Opts$2<t.StringTypeAnnotation>,
  ): asserts this is NodePath<t.StringTypeAnnotation>;
  assertSuper(opts?: Opts$2<t.Super>): asserts this is NodePath<t.Super>;
  assertSwitchCase(
    opts?: Opts$2<t.SwitchCase>,
  ): asserts this is NodePath<t.SwitchCase>;
  assertSwitchStatement(
    opts?: Opts$2<t.SwitchStatement>,
  ): asserts this is NodePath<t.SwitchStatement>;
  assertSymbolTypeAnnotation(
    opts?: Opts$2<t.SymbolTypeAnnotation>,
  ): asserts this is NodePath<t.SymbolTypeAnnotation>;
  assertTSAnyKeyword(
    opts?: Opts$2<t.TSAnyKeyword>,
  ): asserts this is NodePath<t.TSAnyKeyword>;
  assertTSArrayType(
    opts?: Opts$2<t.TSArrayType>,
  ): asserts this is NodePath<t.TSArrayType>;
  assertTSAsExpression(
    opts?: Opts$2<t.TSAsExpression>,
  ): asserts this is NodePath<t.TSAsExpression>;
  assertTSBaseType(
    opts?: Opts$2<t.TSBaseType>,
  ): asserts this is NodePath<t.TSBaseType>;
  assertTSBigIntKeyword(
    opts?: Opts$2<t.TSBigIntKeyword>,
  ): asserts this is NodePath<t.TSBigIntKeyword>;
  assertTSBooleanKeyword(
    opts?: Opts$2<t.TSBooleanKeyword>,
  ): asserts this is NodePath<t.TSBooleanKeyword>;
  assertTSCallSignatureDeclaration(
    opts?: Opts$2<t.TSCallSignatureDeclaration>,
  ): asserts this is NodePath<t.TSCallSignatureDeclaration>;
  assertTSConditionalType(
    opts?: Opts$2<t.TSConditionalType>,
  ): asserts this is NodePath<t.TSConditionalType>;
  assertTSConstructSignatureDeclaration(
    opts?: Opts$2<t.TSConstructSignatureDeclaration>,
  ): asserts this is NodePath<t.TSConstructSignatureDeclaration>;
  assertTSConstructorType(
    opts?: Opts$2<t.TSConstructorType>,
  ): asserts this is NodePath<t.TSConstructorType>;
  assertTSDeclareFunction(
    opts?: Opts$2<t.TSDeclareFunction>,
  ): asserts this is NodePath<t.TSDeclareFunction>;
  assertTSDeclareMethod(
    opts?: Opts$2<t.TSDeclareMethod>,
  ): asserts this is NodePath<t.TSDeclareMethod>;
  assertTSEntityName(
    opts?: Opts$2<t.TSEntityName>,
  ): asserts this is NodePath<t.TSEntityName>;
  assertTSEnumDeclaration(
    opts?: Opts$2<t.TSEnumDeclaration>,
  ): asserts this is NodePath<t.TSEnumDeclaration>;
  assertTSEnumMember(
    opts?: Opts$2<t.TSEnumMember>,
  ): asserts this is NodePath<t.TSEnumMember>;
  assertTSExportAssignment(
    opts?: Opts$2<t.TSExportAssignment>,
  ): asserts this is NodePath<t.TSExportAssignment>;
  assertTSExpressionWithTypeArguments(
    opts?: Opts$2<t.TSExpressionWithTypeArguments>,
  ): asserts this is NodePath<t.TSExpressionWithTypeArguments>;
  assertTSExternalModuleReference(
    opts?: Opts$2<t.TSExternalModuleReference>,
  ): asserts this is NodePath<t.TSExternalModuleReference>;
  assertTSFunctionType(
    opts?: Opts$2<t.TSFunctionType>,
  ): asserts this is NodePath<t.TSFunctionType>;
  assertTSImportEqualsDeclaration(
    opts?: Opts$2<t.TSImportEqualsDeclaration>,
  ): asserts this is NodePath<t.TSImportEqualsDeclaration>;
  assertTSImportType(
    opts?: Opts$2<t.TSImportType>,
  ): asserts this is NodePath<t.TSImportType>;
  assertTSIndexSignature(
    opts?: Opts$2<t.TSIndexSignature>,
  ): asserts this is NodePath<t.TSIndexSignature>;
  assertTSIndexedAccessType(
    opts?: Opts$2<t.TSIndexedAccessType>,
  ): asserts this is NodePath<t.TSIndexedAccessType>;
  assertTSInferType(
    opts?: Opts$2<t.TSInferType>,
  ): asserts this is NodePath<t.TSInferType>;
  assertTSInstantiationExpression(
    opts?: Opts$2<t.TSInstantiationExpression>,
  ): asserts this is NodePath<t.TSInstantiationExpression>;
  assertTSInterfaceBody(
    opts?: Opts$2<t.TSInterfaceBody>,
  ): asserts this is NodePath<t.TSInterfaceBody>;
  assertTSInterfaceDeclaration(
    opts?: Opts$2<t.TSInterfaceDeclaration>,
  ): asserts this is NodePath<t.TSInterfaceDeclaration>;
  assertTSIntersectionType(
    opts?: Opts$2<t.TSIntersectionType>,
  ): asserts this is NodePath<t.TSIntersectionType>;
  assertTSIntrinsicKeyword(
    opts?: Opts$2<t.TSIntrinsicKeyword>,
  ): asserts this is NodePath<t.TSIntrinsicKeyword>;
  assertTSLiteralType(
    opts?: Opts$2<t.TSLiteralType>,
  ): asserts this is NodePath<t.TSLiteralType>;
  assertTSMappedType(
    opts?: Opts$2<t.TSMappedType>,
  ): asserts this is NodePath<t.TSMappedType>;
  assertTSMethodSignature(
    opts?: Opts$2<t.TSMethodSignature>,
  ): asserts this is NodePath<t.TSMethodSignature>;
  assertTSModuleBlock(
    opts?: Opts$2<t.TSModuleBlock>,
  ): asserts this is NodePath<t.TSModuleBlock>;
  assertTSModuleDeclaration(
    opts?: Opts$2<t.TSModuleDeclaration>,
  ): asserts this is NodePath<t.TSModuleDeclaration>;
  assertTSNamedTupleMember(
    opts?: Opts$2<t.TSNamedTupleMember>,
  ): asserts this is NodePath<t.TSNamedTupleMember>;
  assertTSNamespaceExportDeclaration(
    opts?: Opts$2<t.TSNamespaceExportDeclaration>,
  ): asserts this is NodePath<t.TSNamespaceExportDeclaration>;
  assertTSNeverKeyword(
    opts?: Opts$2<t.TSNeverKeyword>,
  ): asserts this is NodePath<t.TSNeverKeyword>;
  assertTSNonNullExpression(
    opts?: Opts$2<t.TSNonNullExpression>,
  ): asserts this is NodePath<t.TSNonNullExpression>;
  assertTSNullKeyword(
    opts?: Opts$2<t.TSNullKeyword>,
  ): asserts this is NodePath<t.TSNullKeyword>;
  assertTSNumberKeyword(
    opts?: Opts$2<t.TSNumberKeyword>,
  ): asserts this is NodePath<t.TSNumberKeyword>;
  assertTSObjectKeyword(
    opts?: Opts$2<t.TSObjectKeyword>,
  ): asserts this is NodePath<t.TSObjectKeyword>;
  assertTSOptionalType(
    opts?: Opts$2<t.TSOptionalType>,
  ): asserts this is NodePath<t.TSOptionalType>;
  assertTSParameterProperty(
    opts?: Opts$2<t.TSParameterProperty>,
  ): asserts this is NodePath<t.TSParameterProperty>;
  assertTSParenthesizedType(
    opts?: Opts$2<t.TSParenthesizedType>,
  ): asserts this is NodePath<t.TSParenthesizedType>;
  assertTSPropertySignature(
    opts?: Opts$2<t.TSPropertySignature>,
  ): asserts this is NodePath<t.TSPropertySignature>;
  assertTSQualifiedName(
    opts?: Opts$2<t.TSQualifiedName>,
  ): asserts this is NodePath<t.TSQualifiedName>;
  assertTSRestType(
    opts?: Opts$2<t.TSRestType>,
  ): asserts this is NodePath<t.TSRestType>;
  assertTSSatisfiesExpression(
    opts?: Opts$2<t.TSSatisfiesExpression>,
  ): asserts this is NodePath<t.TSSatisfiesExpression>;
  assertTSStringKeyword(
    opts?: Opts$2<t.TSStringKeyword>,
  ): asserts this is NodePath<t.TSStringKeyword>;
  assertTSSymbolKeyword(
    opts?: Opts$2<t.TSSymbolKeyword>,
  ): asserts this is NodePath<t.TSSymbolKeyword>;
  assertTSThisType(
    opts?: Opts$2<t.TSThisType>,
  ): asserts this is NodePath<t.TSThisType>;
  assertTSTupleType(
    opts?: Opts$2<t.TSTupleType>,
  ): asserts this is NodePath<t.TSTupleType>;
  assertTSType(opts?: Opts$2<t.TSType>): asserts this is NodePath<t.TSType>;
  assertTSTypeAliasDeclaration(
    opts?: Opts$2<t.TSTypeAliasDeclaration>,
  ): asserts this is NodePath<t.TSTypeAliasDeclaration>;
  assertTSTypeAnnotation(
    opts?: Opts$2<t.TSTypeAnnotation>,
  ): asserts this is NodePath<t.TSTypeAnnotation>;
  assertTSTypeAssertion(
    opts?: Opts$2<t.TSTypeAssertion>,
  ): asserts this is NodePath<t.TSTypeAssertion>;
  assertTSTypeElement(
    opts?: Opts$2<t.TSTypeElement>,
  ): asserts this is NodePath<t.TSTypeElement>;
  assertTSTypeLiteral(
    opts?: Opts$2<t.TSTypeLiteral>,
  ): asserts this is NodePath<t.TSTypeLiteral>;
  assertTSTypeOperator(
    opts?: Opts$2<t.TSTypeOperator>,
  ): asserts this is NodePath<t.TSTypeOperator>;
  assertTSTypeParameter(
    opts?: Opts$2<t.TSTypeParameter>,
  ): asserts this is NodePath<t.TSTypeParameter>;
  assertTSTypeParameterDeclaration(
    opts?: Opts$2<t.TSTypeParameterDeclaration>,
  ): asserts this is NodePath<t.TSTypeParameterDeclaration>;
  assertTSTypeParameterInstantiation(
    opts?: Opts$2<t.TSTypeParameterInstantiation>,
  ): asserts this is NodePath<t.TSTypeParameterInstantiation>;
  assertTSTypePredicate(
    opts?: Opts$2<t.TSTypePredicate>,
  ): asserts this is NodePath<t.TSTypePredicate>;
  assertTSTypeQuery(
    opts?: Opts$2<t.TSTypeQuery>,
  ): asserts this is NodePath<t.TSTypeQuery>;
  assertTSTypeReference(
    opts?: Opts$2<t.TSTypeReference>,
  ): asserts this is NodePath<t.TSTypeReference>;
  assertTSUndefinedKeyword(
    opts?: Opts$2<t.TSUndefinedKeyword>,
  ): asserts this is NodePath<t.TSUndefinedKeyword>;
  assertTSUnionType(
    opts?: Opts$2<t.TSUnionType>,
  ): asserts this is NodePath<t.TSUnionType>;
  assertTSUnknownKeyword(
    opts?: Opts$2<t.TSUnknownKeyword>,
  ): asserts this is NodePath<t.TSUnknownKeyword>;
  assertTSVoidKeyword(
    opts?: Opts$2<t.TSVoidKeyword>,
  ): asserts this is NodePath<t.TSVoidKeyword>;
  assertTaggedTemplateExpression(
    opts?: Opts$2<t.TaggedTemplateExpression>,
  ): asserts this is NodePath<t.TaggedTemplateExpression>;
  assertTemplateElement(
    opts?: Opts$2<t.TemplateElement>,
  ): asserts this is NodePath<t.TemplateElement>;
  assertTemplateLiteral(
    opts?: Opts$2<t.TemplateLiteral>,
  ): asserts this is NodePath<t.TemplateLiteral>;
  assertTerminatorless(
    opts?: Opts$2<t.Terminatorless>,
  ): asserts this is NodePath<t.Terminatorless>;
  assertThisExpression(
    opts?: Opts$2<t.ThisExpression>,
  ): asserts this is NodePath<t.ThisExpression>;
  assertThisTypeAnnotation(
    opts?: Opts$2<t.ThisTypeAnnotation>,
  ): asserts this is NodePath<t.ThisTypeAnnotation>;
  assertThrowStatement(
    opts?: Opts$2<t.ThrowStatement>,
  ): asserts this is NodePath<t.ThrowStatement>;
  assertTopicReference(
    opts?: Opts$2<t.TopicReference>,
  ): asserts this is NodePath<t.TopicReference>;
  assertTryStatement(
    opts?: Opts$2<t.TryStatement>,
  ): asserts this is NodePath<t.TryStatement>;
  assertTupleExpression(
    opts?: Opts$2<t.TupleExpression>,
  ): asserts this is NodePath<t.TupleExpression>;
  assertTupleTypeAnnotation(
    opts?: Opts$2<t.TupleTypeAnnotation>,
  ): asserts this is NodePath<t.TupleTypeAnnotation>;
  assertTypeAlias(
    opts?: Opts$2<t.TypeAlias>,
  ): asserts this is NodePath<t.TypeAlias>;
  assertTypeAnnotation(
    opts?: Opts$2<t.TypeAnnotation>,
  ): asserts this is NodePath<t.TypeAnnotation>;
  assertTypeCastExpression(
    opts?: Opts$2<t.TypeCastExpression>,
  ): asserts this is NodePath<t.TypeCastExpression>;
  assertTypeParameter(
    opts?: Opts$2<t.TypeParameter>,
  ): asserts this is NodePath<t.TypeParameter>;
  assertTypeParameterDeclaration(
    opts?: Opts$2<t.TypeParameterDeclaration>,
  ): asserts this is NodePath<t.TypeParameterDeclaration>;
  assertTypeParameterInstantiation(
    opts?: Opts$2<t.TypeParameterInstantiation>,
  ): asserts this is NodePath<t.TypeParameterInstantiation>;
  assertTypeScript(
    opts?: Opts$2<t.TypeScript>,
  ): asserts this is NodePath<t.TypeScript>;
  assertTypeofTypeAnnotation(
    opts?: Opts$2<t.TypeofTypeAnnotation>,
  ): asserts this is NodePath<t.TypeofTypeAnnotation>;
  assertUnaryExpression(
    opts?: Opts$2<t.UnaryExpression>,
  ): asserts this is NodePath<t.UnaryExpression>;
  assertUnaryLike(
    opts?: Opts$2<t.UnaryLike>,
  ): asserts this is NodePath<t.UnaryLike>;
  assertUnionTypeAnnotation(
    opts?: Opts$2<t.UnionTypeAnnotation>,
  ): asserts this is NodePath<t.UnionTypeAnnotation>;
  assertUpdateExpression(
    opts?: Opts$2<t.UpdateExpression>,
  ): asserts this is NodePath<t.UpdateExpression>;
  assertUserWhitespacable(
    opts?: Opts$2<t.UserWhitespacable>,
  ): asserts this is NodePath<t.UserWhitespacable>;
  assertV8IntrinsicIdentifier(
    opts?: Opts$2<t.V8IntrinsicIdentifier>,
  ): asserts this is NodePath<t.V8IntrinsicIdentifier>;
  assertVariableDeclaration(
    opts?: Opts$2<t.VariableDeclaration>,
  ): asserts this is NodePath<t.VariableDeclaration>;
  assertVariableDeclarator(
    opts?: Opts$2<t.VariableDeclarator>,
  ): asserts this is NodePath<t.VariableDeclarator>;
  assertVariance(opts?: Opts$2<t.Variance>): asserts this is NodePath<t.Variance>;
  assertVoidTypeAnnotation(
    opts?: Opts$2<t.VoidTypeAnnotation>,
  ): asserts this is NodePath<t.VoidTypeAnnotation>;
  assertWhile(opts?: Opts$2<t.While>): asserts this is NodePath<t.While>;
  assertWhileStatement(
    opts?: Opts$2<t.WhileStatement>,
  ): asserts this is NodePath<t.WhileStatement>;
  assertWithStatement(
    opts?: Opts$2<t.WithStatement>,
  ): asserts this is NodePath<t.WithStatement>;
  assertYieldExpression(
    opts?: Opts$2<t.YieldExpression>,
  ): asserts this is NodePath<t.YieldExpression>;
}

type Opts$1<Obj> = Partial<{
    [Prop in keyof Obj]: Obj[Prop] extends t.Node ? t.Node : Obj[Prop] extends t.Node[] ? t.Node[] : Obj[Prop];
}>;
interface VirtualTypeNodePathValidators {
    isBindingIdentifier<T extends t.Node>(this: NodePath<T>, opts?: Opts$1<VirtualTypeAliases["BindingIdentifier"]>): this is NodePath<T & VirtualTypeAliases["BindingIdentifier"]>;
    isBlockScoped(opts?: Opts$1<VirtualTypeAliases["BlockScoped"]>): boolean;
    /**
     * @deprecated
     */
    isExistentialTypeParam<T extends t.Node>(this: NodePath<T>, opts?: Opts$1<VirtualTypeAliases["ExistentialTypeParam"]>): this is NodePath<T & VirtualTypeAliases["ExistentialTypeParam"]>;
    isExpression<T extends t.Node>(this: NodePath<T>, opts?: Opts$1<VirtualTypeAliases["Expression"]>): this is NodePath<T & t.Expression>;
    isFlow<T extends t.Node>(this: NodePath<T>, opts?: Opts$1<VirtualTypeAliases["Flow"]>): this is NodePath<T & t.Flow>;
    isForAwaitStatement<T extends t.Node>(this: NodePath<T>, opts?: Opts$1<VirtualTypeAliases["ForAwaitStatement"]>): this is NodePath<T & VirtualTypeAliases["ForAwaitStatement"]>;
    isGenerated(opts?: VirtualTypeAliases["Generated"]): boolean;
    /**
     * @deprecated
     */
    isNumericLiteralTypeAnnotation(opts?: VirtualTypeAliases["NumericLiteralTypeAnnotation"]): void;
    isPure(opts?: VirtualTypeAliases["Pure"]): boolean;
    isReferenced(opts?: VirtualTypeAliases["Referenced"]): boolean;
    isReferencedIdentifier<T extends t.Node>(this: NodePath<T>, opts?: Opts$1<VirtualTypeAliases["ReferencedIdentifier"]>): this is NodePath<T & VirtualTypeAliases["ReferencedIdentifier"]>;
    isReferencedMemberExpression<T extends t.Node>(this: NodePath<T>, opts?: Opts$1<VirtualTypeAliases["ReferencedMemberExpression"]>): this is NodePath<T & VirtualTypeAliases["ReferencedMemberExpression"]>;
    isRestProperty<T extends t.Node>(this: NodePath<T>, opts?: Opts$1<VirtualTypeAliases["RestProperty"]>): this is NodePath<T & t.RestProperty>;
    isScope<T extends t.Node>(this: NodePath<T>, opts?: Opts$1<VirtualTypeAliases["Scope"]>): this is NodePath<T & VirtualTypeAliases["Scope"]>;
    isSpreadProperty<T extends t.Node>(this: NodePath<T>, opts?: Opts$1<VirtualTypeAliases["SpreadProperty"]>): this is NodePath<T & t.SpreadProperty>;
    isStatement<T extends t.Node>(this: NodePath<T>, opts?: Opts$1<VirtualTypeAliases["Statement"]>): this is NodePath<T & t.Statement>;
    isUser(opts?: VirtualTypeAliases["User"]): boolean;
    isVar<T extends t.Node>(this: NodePath<T>, opts?: Opts$1<VirtualTypeAliases["Var"]>): this is NodePath<T & VirtualTypeAliases["Var"]>;
}

/*
 * This file is auto-generated! Do not modify it directly.
 * To re-generate run 'make build'
 */


type Opts<Obj> = Partial<{
  [Prop in keyof Obj]: Obj[Prop] extends t.Node
    ? t.Node
    : Obj[Prop] extends t.Node[]
      ? t.Node[]
      : Obj[Prop];
}>;

interface BaseNodePathValidators {
  isAccessor<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.Accessor>,
  ): this is NodePath<T & t.Accessor>;
  isAnyTypeAnnotation<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.AnyTypeAnnotation>,
  ): this is NodePath<T & t.AnyTypeAnnotation>;
  isArgumentPlaceholder<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.ArgumentPlaceholder>,
  ): this is NodePath<T & t.ArgumentPlaceholder>;
  isArrayExpression<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.ArrayExpression>,
  ): this is NodePath<T & t.ArrayExpression>;
  isArrayPattern<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.ArrayPattern>,
  ): this is NodePath<T & t.ArrayPattern>;
  isArrayTypeAnnotation<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.ArrayTypeAnnotation>,
  ): this is NodePath<T & t.ArrayTypeAnnotation>;
  isArrowFunctionExpression<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.ArrowFunctionExpression>,
  ): this is NodePath<T & t.ArrowFunctionExpression>;
  isAssignmentExpression<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.AssignmentExpression>,
  ): this is NodePath<T & t.AssignmentExpression>;
  isAssignmentPattern<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.AssignmentPattern>,
  ): this is NodePath<T & t.AssignmentPattern>;
  isAwaitExpression<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.AwaitExpression>,
  ): this is NodePath<T & t.AwaitExpression>;
  isBigIntLiteral<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.BigIntLiteral>,
  ): this is NodePath<T & t.BigIntLiteral>;
  isBinary<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.Binary>,
  ): this is NodePath<T & t.Binary>;
  isBinaryExpression<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.BinaryExpression>,
  ): this is NodePath<T & t.BinaryExpression>;
  isBindExpression<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.BindExpression>,
  ): this is NodePath<T & t.BindExpression>;
  isBlock<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.Block>,
  ): this is NodePath<T & t.Block>;
  isBlockParent<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.BlockParent>,
  ): this is NodePath<T & t.BlockParent>;
  isBlockStatement<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.BlockStatement>,
  ): this is NodePath<T & t.BlockStatement>;
  isBooleanLiteral<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.BooleanLiteral>,
  ): this is NodePath<T & t.BooleanLiteral>;
  isBooleanLiteralTypeAnnotation<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.BooleanLiteralTypeAnnotation>,
  ): this is NodePath<T & t.BooleanLiteralTypeAnnotation>;
  isBooleanTypeAnnotation<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.BooleanTypeAnnotation>,
  ): this is NodePath<T & t.BooleanTypeAnnotation>;
  isBreakStatement<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.BreakStatement>,
  ): this is NodePath<T & t.BreakStatement>;
  isCallExpression<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.CallExpression>,
  ): this is NodePath<T & t.CallExpression>;
  isCatchClause<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.CatchClause>,
  ): this is NodePath<T & t.CatchClause>;
  isClass<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.Class>,
  ): this is NodePath<T & t.Class>;
  isClassAccessorProperty<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.ClassAccessorProperty>,
  ): this is NodePath<T & t.ClassAccessorProperty>;
  isClassBody<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.ClassBody>,
  ): this is NodePath<T & t.ClassBody>;
  isClassDeclaration<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.ClassDeclaration>,
  ): this is NodePath<T & t.ClassDeclaration>;
  isClassExpression<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.ClassExpression>,
  ): this is NodePath<T & t.ClassExpression>;
  isClassImplements<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.ClassImplements>,
  ): this is NodePath<T & t.ClassImplements>;
  isClassMethod<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.ClassMethod>,
  ): this is NodePath<T & t.ClassMethod>;
  isClassPrivateMethod<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.ClassPrivateMethod>,
  ): this is NodePath<T & t.ClassPrivateMethod>;
  isClassPrivateProperty<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.ClassPrivateProperty>,
  ): this is NodePath<T & t.ClassPrivateProperty>;
  isClassProperty<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.ClassProperty>,
  ): this is NodePath<T & t.ClassProperty>;
  isCompletionStatement<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.CompletionStatement>,
  ): this is NodePath<T & t.CompletionStatement>;
  isConditional<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.Conditional>,
  ): this is NodePath<T & t.Conditional>;
  isConditionalExpression<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.ConditionalExpression>,
  ): this is NodePath<T & t.ConditionalExpression>;
  isContinueStatement<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.ContinueStatement>,
  ): this is NodePath<T & t.ContinueStatement>;
  isDebuggerStatement<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.DebuggerStatement>,
  ): this is NodePath<T & t.DebuggerStatement>;
  isDecimalLiteral<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.DecimalLiteral>,
  ): this is NodePath<T & t.DecimalLiteral>;
  isDeclaration<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.Declaration>,
  ): this is NodePath<T & t.Declaration>;
  isDeclareClass<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.DeclareClass>,
  ): this is NodePath<T & t.DeclareClass>;
  isDeclareExportAllDeclaration<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.DeclareExportAllDeclaration>,
  ): this is NodePath<T & t.DeclareExportAllDeclaration>;
  isDeclareExportDeclaration<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.DeclareExportDeclaration>,
  ): this is NodePath<T & t.DeclareExportDeclaration>;
  isDeclareFunction<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.DeclareFunction>,
  ): this is NodePath<T & t.DeclareFunction>;
  isDeclareInterface<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.DeclareInterface>,
  ): this is NodePath<T & t.DeclareInterface>;
  isDeclareModule<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.DeclareModule>,
  ): this is NodePath<T & t.DeclareModule>;
  isDeclareModuleExports<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.DeclareModuleExports>,
  ): this is NodePath<T & t.DeclareModuleExports>;
  isDeclareOpaqueType<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.DeclareOpaqueType>,
  ): this is NodePath<T & t.DeclareOpaqueType>;
  isDeclareTypeAlias<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.DeclareTypeAlias>,
  ): this is NodePath<T & t.DeclareTypeAlias>;
  isDeclareVariable<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.DeclareVariable>,
  ): this is NodePath<T & t.DeclareVariable>;
  isDeclaredPredicate<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.DeclaredPredicate>,
  ): this is NodePath<T & t.DeclaredPredicate>;
  isDecorator<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.Decorator>,
  ): this is NodePath<T & t.Decorator>;
  isDirective<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.Directive>,
  ): this is NodePath<T & t.Directive>;
  isDirectiveLiteral<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.DirectiveLiteral>,
  ): this is NodePath<T & t.DirectiveLiteral>;
  isDoExpression<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.DoExpression>,
  ): this is NodePath<T & t.DoExpression>;
  isDoWhileStatement<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.DoWhileStatement>,
  ): this is NodePath<T & t.DoWhileStatement>;
  isEmptyStatement<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.EmptyStatement>,
  ): this is NodePath<T & t.EmptyStatement>;
  isEmptyTypeAnnotation<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.EmptyTypeAnnotation>,
  ): this is NodePath<T & t.EmptyTypeAnnotation>;
  isEnumBody<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.EnumBody>,
  ): this is NodePath<T & t.EnumBody>;
  isEnumBooleanBody<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.EnumBooleanBody>,
  ): this is NodePath<T & t.EnumBooleanBody>;
  isEnumBooleanMember<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.EnumBooleanMember>,
  ): this is NodePath<T & t.EnumBooleanMember>;
  isEnumDeclaration<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.EnumDeclaration>,
  ): this is NodePath<T & t.EnumDeclaration>;
  isEnumDefaultedMember<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.EnumDefaultedMember>,
  ): this is NodePath<T & t.EnumDefaultedMember>;
  isEnumMember<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.EnumMember>,
  ): this is NodePath<T & t.EnumMember>;
  isEnumNumberBody<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.EnumNumberBody>,
  ): this is NodePath<T & t.EnumNumberBody>;
  isEnumNumberMember<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.EnumNumberMember>,
  ): this is NodePath<T & t.EnumNumberMember>;
  isEnumStringBody<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.EnumStringBody>,
  ): this is NodePath<T & t.EnumStringBody>;
  isEnumStringMember<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.EnumStringMember>,
  ): this is NodePath<T & t.EnumStringMember>;
  isEnumSymbolBody<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.EnumSymbolBody>,
  ): this is NodePath<T & t.EnumSymbolBody>;
  isExistsTypeAnnotation<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.ExistsTypeAnnotation>,
  ): this is NodePath<T & t.ExistsTypeAnnotation>;
  isExportAllDeclaration<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.ExportAllDeclaration>,
  ): this is NodePath<T & t.ExportAllDeclaration>;
  isExportDeclaration<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.ExportDeclaration>,
  ): this is NodePath<T & t.ExportDeclaration>;
  isExportDefaultDeclaration<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.ExportDefaultDeclaration>,
  ): this is NodePath<T & t.ExportDefaultDeclaration>;
  isExportDefaultSpecifier<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.ExportDefaultSpecifier>,
  ): this is NodePath<T & t.ExportDefaultSpecifier>;
  isExportNamedDeclaration<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.ExportNamedDeclaration>,
  ): this is NodePath<T & t.ExportNamedDeclaration>;
  isExportNamespaceSpecifier<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.ExportNamespaceSpecifier>,
  ): this is NodePath<T & t.ExportNamespaceSpecifier>;
  isExportSpecifier<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.ExportSpecifier>,
  ): this is NodePath<T & t.ExportSpecifier>;
  isExpression<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.Expression>,
  ): this is NodePath<T & t.Expression>;
  isExpressionStatement<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.ExpressionStatement>,
  ): this is NodePath<T & t.ExpressionStatement>;
  isExpressionWrapper<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.ExpressionWrapper>,
  ): this is NodePath<T & t.ExpressionWrapper>;
  isFile<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.File>,
  ): this is NodePath<T & t.File>;
  isFlow<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.Flow>,
  ): this is NodePath<T & t.Flow>;
  isFlowBaseAnnotation<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.FlowBaseAnnotation>,
  ): this is NodePath<T & t.FlowBaseAnnotation>;
  isFlowDeclaration<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.FlowDeclaration>,
  ): this is NodePath<T & t.FlowDeclaration>;
  isFlowPredicate<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.FlowPredicate>,
  ): this is NodePath<T & t.FlowPredicate>;
  isFlowType<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.FlowType>,
  ): this is NodePath<T & t.FlowType>;
  isFor<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.For>,
  ): this is NodePath<T & t.For>;
  isForInStatement<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.ForInStatement>,
  ): this is NodePath<T & t.ForInStatement>;
  isForOfStatement<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.ForOfStatement>,
  ): this is NodePath<T & t.ForOfStatement>;
  isForStatement<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.ForStatement>,
  ): this is NodePath<T & t.ForStatement>;
  isForXStatement<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.ForXStatement>,
  ): this is NodePath<T & t.ForXStatement>;
  isFunction<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.Function>,
  ): this is NodePath<T & t.Function>;
  isFunctionDeclaration<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.FunctionDeclaration>,
  ): this is NodePath<T & t.FunctionDeclaration>;
  isFunctionExpression<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.FunctionExpression>,
  ): this is NodePath<T & t.FunctionExpression>;
  isFunctionParent<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.FunctionParent>,
  ): this is NodePath<T & t.FunctionParent>;
  isFunctionTypeAnnotation<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.FunctionTypeAnnotation>,
  ): this is NodePath<T & t.FunctionTypeAnnotation>;
  isFunctionTypeParam<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.FunctionTypeParam>,
  ): this is NodePath<T & t.FunctionTypeParam>;
  isGenericTypeAnnotation<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.GenericTypeAnnotation>,
  ): this is NodePath<T & t.GenericTypeAnnotation>;
  isIdentifier<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.Identifier>,
  ): this is NodePath<T & t.Identifier>;
  isIfStatement<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.IfStatement>,
  ): this is NodePath<T & t.IfStatement>;
  isImmutable<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.Immutable>,
  ): this is NodePath<T & t.Immutable>;
  isImport<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.Import>,
  ): this is NodePath<T & t.Import>;
  isImportAttribute<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.ImportAttribute>,
  ): this is NodePath<T & t.ImportAttribute>;
  isImportDeclaration<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.ImportDeclaration>,
  ): this is NodePath<T & t.ImportDeclaration>;
  isImportDefaultSpecifier<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.ImportDefaultSpecifier>,
  ): this is NodePath<T & t.ImportDefaultSpecifier>;
  isImportExpression<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.ImportExpression>,
  ): this is NodePath<T & t.ImportExpression>;
  isImportNamespaceSpecifier<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.ImportNamespaceSpecifier>,
  ): this is NodePath<T & t.ImportNamespaceSpecifier>;
  isImportOrExportDeclaration<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.ImportOrExportDeclaration>,
  ): this is NodePath<T & t.ImportOrExportDeclaration>;
  isImportSpecifier<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.ImportSpecifier>,
  ): this is NodePath<T & t.ImportSpecifier>;
  isIndexedAccessType<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.IndexedAccessType>,
  ): this is NodePath<T & t.IndexedAccessType>;
  isInferredPredicate<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.InferredPredicate>,
  ): this is NodePath<T & t.InferredPredicate>;
  isInterfaceDeclaration<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.InterfaceDeclaration>,
  ): this is NodePath<T & t.InterfaceDeclaration>;
  isInterfaceExtends<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.InterfaceExtends>,
  ): this is NodePath<T & t.InterfaceExtends>;
  isInterfaceTypeAnnotation<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.InterfaceTypeAnnotation>,
  ): this is NodePath<T & t.InterfaceTypeAnnotation>;
  isInterpreterDirective<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.InterpreterDirective>,
  ): this is NodePath<T & t.InterpreterDirective>;
  isIntersectionTypeAnnotation<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.IntersectionTypeAnnotation>,
  ): this is NodePath<T & t.IntersectionTypeAnnotation>;
  isJSX<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.JSX>,
  ): this is NodePath<T & t.JSX>;
  isJSXAttribute<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.JSXAttribute>,
  ): this is NodePath<T & t.JSXAttribute>;
  isJSXClosingElement<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.JSXClosingElement>,
  ): this is NodePath<T & t.JSXClosingElement>;
  isJSXClosingFragment<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.JSXClosingFragment>,
  ): this is NodePath<T & t.JSXClosingFragment>;
  isJSXElement<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.JSXElement>,
  ): this is NodePath<T & t.JSXElement>;
  isJSXEmptyExpression<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.JSXEmptyExpression>,
  ): this is NodePath<T & t.JSXEmptyExpression>;
  isJSXExpressionContainer<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.JSXExpressionContainer>,
  ): this is NodePath<T & t.JSXExpressionContainer>;
  isJSXFragment<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.JSXFragment>,
  ): this is NodePath<T & t.JSXFragment>;
  isJSXIdentifier<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.JSXIdentifier>,
  ): this is NodePath<T & t.JSXIdentifier>;
  isJSXMemberExpression<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.JSXMemberExpression>,
  ): this is NodePath<T & t.JSXMemberExpression>;
  isJSXNamespacedName<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.JSXNamespacedName>,
  ): this is NodePath<T & t.JSXNamespacedName>;
  isJSXOpeningElement<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.JSXOpeningElement>,
  ): this is NodePath<T & t.JSXOpeningElement>;
  isJSXOpeningFragment<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.JSXOpeningFragment>,
  ): this is NodePath<T & t.JSXOpeningFragment>;
  isJSXSpreadAttribute<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.JSXSpreadAttribute>,
  ): this is NodePath<T & t.JSXSpreadAttribute>;
  isJSXSpreadChild<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.JSXSpreadChild>,
  ): this is NodePath<T & t.JSXSpreadChild>;
  isJSXText<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.JSXText>,
  ): this is NodePath<T & t.JSXText>;
  isLVal<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.LVal>,
  ): this is NodePath<T & t.LVal>;
  isLabeledStatement<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.LabeledStatement>,
  ): this is NodePath<T & t.LabeledStatement>;
  isLiteral<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.Literal>,
  ): this is NodePath<T & t.Literal>;
  isLogicalExpression<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.LogicalExpression>,
  ): this is NodePath<T & t.LogicalExpression>;
  isLoop<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.Loop>,
  ): this is NodePath<T & t.Loop>;
  isMemberExpression<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.MemberExpression>,
  ): this is NodePath<T & t.MemberExpression>;
  isMetaProperty<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.MetaProperty>,
  ): this is NodePath<T & t.MetaProperty>;
  isMethod<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.Method>,
  ): this is NodePath<T & t.Method>;
  isMiscellaneous<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.Miscellaneous>,
  ): this is NodePath<T & t.Miscellaneous>;
  isMixedTypeAnnotation<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.MixedTypeAnnotation>,
  ): this is NodePath<T & t.MixedTypeAnnotation>;
  isModuleDeclaration<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.ModuleDeclaration>,
  ): this is NodePath<T & t.ModuleDeclaration>;
  isModuleExpression<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.ModuleExpression>,
  ): this is NodePath<T & t.ModuleExpression>;
  isModuleSpecifier<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.ModuleSpecifier>,
  ): this is NodePath<T & t.ModuleSpecifier>;
  isNewExpression<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.NewExpression>,
  ): this is NodePath<T & t.NewExpression>;
  isNoop<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.Noop>,
  ): this is NodePath<T & t.Noop>;
  isNullLiteral<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.NullLiteral>,
  ): this is NodePath<T & t.NullLiteral>;
  isNullLiteralTypeAnnotation<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.NullLiteralTypeAnnotation>,
  ): this is NodePath<T & t.NullLiteralTypeAnnotation>;
  isNullableTypeAnnotation<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.NullableTypeAnnotation>,
  ): this is NodePath<T & t.NullableTypeAnnotation>;
  isNumberLiteral<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.NumberLiteral>,
  ): this is NodePath<T & t.NumberLiteral>;
  isNumberLiteralTypeAnnotation<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.NumberLiteralTypeAnnotation>,
  ): this is NodePath<T & t.NumberLiteralTypeAnnotation>;
  isNumberTypeAnnotation<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.NumberTypeAnnotation>,
  ): this is NodePath<T & t.NumberTypeAnnotation>;
  isNumericLiteral<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.NumericLiteral>,
  ): this is NodePath<T & t.NumericLiteral>;
  isObjectExpression<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.ObjectExpression>,
  ): this is NodePath<T & t.ObjectExpression>;
  isObjectMember<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.ObjectMember>,
  ): this is NodePath<T & t.ObjectMember>;
  isObjectMethod<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.ObjectMethod>,
  ): this is NodePath<T & t.ObjectMethod>;
  isObjectPattern<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.ObjectPattern>,
  ): this is NodePath<T & t.ObjectPattern>;
  isObjectProperty<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.ObjectProperty>,
  ): this is NodePath<T & t.ObjectProperty>;
  isObjectTypeAnnotation<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.ObjectTypeAnnotation>,
  ): this is NodePath<T & t.ObjectTypeAnnotation>;
  isObjectTypeCallProperty<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.ObjectTypeCallProperty>,
  ): this is NodePath<T & t.ObjectTypeCallProperty>;
  isObjectTypeIndexer<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.ObjectTypeIndexer>,
  ): this is NodePath<T & t.ObjectTypeIndexer>;
  isObjectTypeInternalSlot<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.ObjectTypeInternalSlot>,
  ): this is NodePath<T & t.ObjectTypeInternalSlot>;
  isObjectTypeProperty<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.ObjectTypeProperty>,
  ): this is NodePath<T & t.ObjectTypeProperty>;
  isObjectTypeSpreadProperty<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.ObjectTypeSpreadProperty>,
  ): this is NodePath<T & t.ObjectTypeSpreadProperty>;
  isOpaqueType<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.OpaqueType>,
  ): this is NodePath<T & t.OpaqueType>;
  isOptionalCallExpression<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.OptionalCallExpression>,
  ): this is NodePath<T & t.OptionalCallExpression>;
  isOptionalIndexedAccessType<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.OptionalIndexedAccessType>,
  ): this is NodePath<T & t.OptionalIndexedAccessType>;
  isOptionalMemberExpression<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.OptionalMemberExpression>,
  ): this is NodePath<T & t.OptionalMemberExpression>;
  isParenthesizedExpression<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.ParenthesizedExpression>,
  ): this is NodePath<T & t.ParenthesizedExpression>;
  isPattern<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.Pattern>,
  ): this is NodePath<T & t.Pattern>;
  isPatternLike<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.PatternLike>,
  ): this is NodePath<T & t.PatternLike>;
  isPipelineBareFunction<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.PipelineBareFunction>,
  ): this is NodePath<T & t.PipelineBareFunction>;
  isPipelinePrimaryTopicReference<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.PipelinePrimaryTopicReference>,
  ): this is NodePath<T & t.PipelinePrimaryTopicReference>;
  isPipelineTopicExpression<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.PipelineTopicExpression>,
  ): this is NodePath<T & t.PipelineTopicExpression>;
  isPlaceholder<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.Placeholder>,
  ): this is NodePath<T & t.Placeholder>;
  isPrivate<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.Private>,
  ): this is NodePath<T & t.Private>;
  isPrivateName<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.PrivateName>,
  ): this is NodePath<T & t.PrivateName>;
  isProgram<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.Program>,
  ): this is NodePath<T & t.Program>;
  isProperty<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.Property>,
  ): this is NodePath<T & t.Property>;
  isPureish<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.Pureish>,
  ): this is NodePath<T & t.Pureish>;
  isQualifiedTypeIdentifier<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.QualifiedTypeIdentifier>,
  ): this is NodePath<T & t.QualifiedTypeIdentifier>;
  isRecordExpression<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.RecordExpression>,
  ): this is NodePath<T & t.RecordExpression>;
  isRegExpLiteral<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.RegExpLiteral>,
  ): this is NodePath<T & t.RegExpLiteral>;
  isRegexLiteral<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.RegexLiteral>,
  ): this is NodePath<T & t.RegexLiteral>;
  isRestElement<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.RestElement>,
  ): this is NodePath<T & t.RestElement>;
  isRestProperty<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.RestProperty>,
  ): this is NodePath<T & t.RestProperty>;
  isReturnStatement<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.ReturnStatement>,
  ): this is NodePath<T & t.ReturnStatement>;
  isScopable<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.Scopable>,
  ): this is NodePath<T & t.Scopable>;
  isSequenceExpression<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.SequenceExpression>,
  ): this is NodePath<T & t.SequenceExpression>;
  isSpreadElement<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.SpreadElement>,
  ): this is NodePath<T & t.SpreadElement>;
  isSpreadProperty<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.SpreadProperty>,
  ): this is NodePath<T & t.SpreadProperty>;
  isStandardized<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.Standardized>,
  ): this is NodePath<T & t.Standardized>;
  isStatement<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.Statement>,
  ): this is NodePath<T & t.Statement>;
  isStaticBlock<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.StaticBlock>,
  ): this is NodePath<T & t.StaticBlock>;
  isStringLiteral<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.StringLiteral>,
  ): this is NodePath<T & t.StringLiteral>;
  isStringLiteralTypeAnnotation<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.StringLiteralTypeAnnotation>,
  ): this is NodePath<T & t.StringLiteralTypeAnnotation>;
  isStringTypeAnnotation<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.StringTypeAnnotation>,
  ): this is NodePath<T & t.StringTypeAnnotation>;
  isSuper<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.Super>,
  ): this is NodePath<T & t.Super>;
  isSwitchCase<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.SwitchCase>,
  ): this is NodePath<T & t.SwitchCase>;
  isSwitchStatement<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.SwitchStatement>,
  ): this is NodePath<T & t.SwitchStatement>;
  isSymbolTypeAnnotation<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.SymbolTypeAnnotation>,
  ): this is NodePath<T & t.SymbolTypeAnnotation>;
  isTSAnyKeyword<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TSAnyKeyword>,
  ): this is NodePath<T & t.TSAnyKeyword>;
  isTSArrayType<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TSArrayType>,
  ): this is NodePath<T & t.TSArrayType>;
  isTSAsExpression<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TSAsExpression>,
  ): this is NodePath<T & t.TSAsExpression>;
  isTSBaseType<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TSBaseType>,
  ): this is NodePath<T & t.TSBaseType>;
  isTSBigIntKeyword<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TSBigIntKeyword>,
  ): this is NodePath<T & t.TSBigIntKeyword>;
  isTSBooleanKeyword<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TSBooleanKeyword>,
  ): this is NodePath<T & t.TSBooleanKeyword>;
  isTSCallSignatureDeclaration<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TSCallSignatureDeclaration>,
  ): this is NodePath<T & t.TSCallSignatureDeclaration>;
  isTSConditionalType<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TSConditionalType>,
  ): this is NodePath<T & t.TSConditionalType>;
  isTSConstructSignatureDeclaration<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TSConstructSignatureDeclaration>,
  ): this is NodePath<T & t.TSConstructSignatureDeclaration>;
  isTSConstructorType<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TSConstructorType>,
  ): this is NodePath<T & t.TSConstructorType>;
  isTSDeclareFunction<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TSDeclareFunction>,
  ): this is NodePath<T & t.TSDeclareFunction>;
  isTSDeclareMethod<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TSDeclareMethod>,
  ): this is NodePath<T & t.TSDeclareMethod>;
  isTSEntityName<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TSEntityName>,
  ): this is NodePath<T & t.TSEntityName>;
  isTSEnumDeclaration<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TSEnumDeclaration>,
  ): this is NodePath<T & t.TSEnumDeclaration>;
  isTSEnumMember<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TSEnumMember>,
  ): this is NodePath<T & t.TSEnumMember>;
  isTSExportAssignment<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TSExportAssignment>,
  ): this is NodePath<T & t.TSExportAssignment>;
  isTSExpressionWithTypeArguments<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TSExpressionWithTypeArguments>,
  ): this is NodePath<T & t.TSExpressionWithTypeArguments>;
  isTSExternalModuleReference<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TSExternalModuleReference>,
  ): this is NodePath<T & t.TSExternalModuleReference>;
  isTSFunctionType<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TSFunctionType>,
  ): this is NodePath<T & t.TSFunctionType>;
  isTSImportEqualsDeclaration<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TSImportEqualsDeclaration>,
  ): this is NodePath<T & t.TSImportEqualsDeclaration>;
  isTSImportType<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TSImportType>,
  ): this is NodePath<T & t.TSImportType>;
  isTSIndexSignature<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TSIndexSignature>,
  ): this is NodePath<T & t.TSIndexSignature>;
  isTSIndexedAccessType<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TSIndexedAccessType>,
  ): this is NodePath<T & t.TSIndexedAccessType>;
  isTSInferType<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TSInferType>,
  ): this is NodePath<T & t.TSInferType>;
  isTSInstantiationExpression<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TSInstantiationExpression>,
  ): this is NodePath<T & t.TSInstantiationExpression>;
  isTSInterfaceBody<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TSInterfaceBody>,
  ): this is NodePath<T & t.TSInterfaceBody>;
  isTSInterfaceDeclaration<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TSInterfaceDeclaration>,
  ): this is NodePath<T & t.TSInterfaceDeclaration>;
  isTSIntersectionType<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TSIntersectionType>,
  ): this is NodePath<T & t.TSIntersectionType>;
  isTSIntrinsicKeyword<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TSIntrinsicKeyword>,
  ): this is NodePath<T & t.TSIntrinsicKeyword>;
  isTSLiteralType<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TSLiteralType>,
  ): this is NodePath<T & t.TSLiteralType>;
  isTSMappedType<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TSMappedType>,
  ): this is NodePath<T & t.TSMappedType>;
  isTSMethodSignature<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TSMethodSignature>,
  ): this is NodePath<T & t.TSMethodSignature>;
  isTSModuleBlock<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TSModuleBlock>,
  ): this is NodePath<T & t.TSModuleBlock>;
  isTSModuleDeclaration<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TSModuleDeclaration>,
  ): this is NodePath<T & t.TSModuleDeclaration>;
  isTSNamedTupleMember<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TSNamedTupleMember>,
  ): this is NodePath<T & t.TSNamedTupleMember>;
  isTSNamespaceExportDeclaration<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TSNamespaceExportDeclaration>,
  ): this is NodePath<T & t.TSNamespaceExportDeclaration>;
  isTSNeverKeyword<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TSNeverKeyword>,
  ): this is NodePath<T & t.TSNeverKeyword>;
  isTSNonNullExpression<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TSNonNullExpression>,
  ): this is NodePath<T & t.TSNonNullExpression>;
  isTSNullKeyword<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TSNullKeyword>,
  ): this is NodePath<T & t.TSNullKeyword>;
  isTSNumberKeyword<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TSNumberKeyword>,
  ): this is NodePath<T & t.TSNumberKeyword>;
  isTSObjectKeyword<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TSObjectKeyword>,
  ): this is NodePath<T & t.TSObjectKeyword>;
  isTSOptionalType<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TSOptionalType>,
  ): this is NodePath<T & t.TSOptionalType>;
  isTSParameterProperty<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TSParameterProperty>,
  ): this is NodePath<T & t.TSParameterProperty>;
  isTSParenthesizedType<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TSParenthesizedType>,
  ): this is NodePath<T & t.TSParenthesizedType>;
  isTSPropertySignature<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TSPropertySignature>,
  ): this is NodePath<T & t.TSPropertySignature>;
  isTSQualifiedName<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TSQualifiedName>,
  ): this is NodePath<T & t.TSQualifiedName>;
  isTSRestType<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TSRestType>,
  ): this is NodePath<T & t.TSRestType>;
  isTSSatisfiesExpression<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TSSatisfiesExpression>,
  ): this is NodePath<T & t.TSSatisfiesExpression>;
  isTSStringKeyword<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TSStringKeyword>,
  ): this is NodePath<T & t.TSStringKeyword>;
  isTSSymbolKeyword<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TSSymbolKeyword>,
  ): this is NodePath<T & t.TSSymbolKeyword>;
  isTSThisType<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TSThisType>,
  ): this is NodePath<T & t.TSThisType>;
  isTSTupleType<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TSTupleType>,
  ): this is NodePath<T & t.TSTupleType>;
  isTSType<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TSType>,
  ): this is NodePath<T & t.TSType>;
  isTSTypeAliasDeclaration<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TSTypeAliasDeclaration>,
  ): this is NodePath<T & t.TSTypeAliasDeclaration>;
  isTSTypeAnnotation<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TSTypeAnnotation>,
  ): this is NodePath<T & t.TSTypeAnnotation>;
  isTSTypeAssertion<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TSTypeAssertion>,
  ): this is NodePath<T & t.TSTypeAssertion>;
  isTSTypeElement<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TSTypeElement>,
  ): this is NodePath<T & t.TSTypeElement>;
  isTSTypeLiteral<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TSTypeLiteral>,
  ): this is NodePath<T & t.TSTypeLiteral>;
  isTSTypeOperator<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TSTypeOperator>,
  ): this is NodePath<T & t.TSTypeOperator>;
  isTSTypeParameter<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TSTypeParameter>,
  ): this is NodePath<T & t.TSTypeParameter>;
  isTSTypeParameterDeclaration<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TSTypeParameterDeclaration>,
  ): this is NodePath<T & t.TSTypeParameterDeclaration>;
  isTSTypeParameterInstantiation<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TSTypeParameterInstantiation>,
  ): this is NodePath<T & t.TSTypeParameterInstantiation>;
  isTSTypePredicate<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TSTypePredicate>,
  ): this is NodePath<T & t.TSTypePredicate>;
  isTSTypeQuery<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TSTypeQuery>,
  ): this is NodePath<T & t.TSTypeQuery>;
  isTSTypeReference<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TSTypeReference>,
  ): this is NodePath<T & t.TSTypeReference>;
  isTSUndefinedKeyword<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TSUndefinedKeyword>,
  ): this is NodePath<T & t.TSUndefinedKeyword>;
  isTSUnionType<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TSUnionType>,
  ): this is NodePath<T & t.TSUnionType>;
  isTSUnknownKeyword<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TSUnknownKeyword>,
  ): this is NodePath<T & t.TSUnknownKeyword>;
  isTSVoidKeyword<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TSVoidKeyword>,
  ): this is NodePath<T & t.TSVoidKeyword>;
  isTaggedTemplateExpression<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TaggedTemplateExpression>,
  ): this is NodePath<T & t.TaggedTemplateExpression>;
  isTemplateElement<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TemplateElement>,
  ): this is NodePath<T & t.TemplateElement>;
  isTemplateLiteral<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TemplateLiteral>,
  ): this is NodePath<T & t.TemplateLiteral>;
  isTerminatorless<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.Terminatorless>,
  ): this is NodePath<T & t.Terminatorless>;
  isThisExpression<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.ThisExpression>,
  ): this is NodePath<T & t.ThisExpression>;
  isThisTypeAnnotation<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.ThisTypeAnnotation>,
  ): this is NodePath<T & t.ThisTypeAnnotation>;
  isThrowStatement<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.ThrowStatement>,
  ): this is NodePath<T & t.ThrowStatement>;
  isTopicReference<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TopicReference>,
  ): this is NodePath<T & t.TopicReference>;
  isTryStatement<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TryStatement>,
  ): this is NodePath<T & t.TryStatement>;
  isTupleExpression<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TupleExpression>,
  ): this is NodePath<T & t.TupleExpression>;
  isTupleTypeAnnotation<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TupleTypeAnnotation>,
  ): this is NodePath<T & t.TupleTypeAnnotation>;
  isTypeAlias<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TypeAlias>,
  ): this is NodePath<T & t.TypeAlias>;
  isTypeAnnotation<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TypeAnnotation>,
  ): this is NodePath<T & t.TypeAnnotation>;
  isTypeCastExpression<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TypeCastExpression>,
  ): this is NodePath<T & t.TypeCastExpression>;
  isTypeParameter<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TypeParameter>,
  ): this is NodePath<T & t.TypeParameter>;
  isTypeParameterDeclaration<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TypeParameterDeclaration>,
  ): this is NodePath<T & t.TypeParameterDeclaration>;
  isTypeParameterInstantiation<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TypeParameterInstantiation>,
  ): this is NodePath<T & t.TypeParameterInstantiation>;
  isTypeScript<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TypeScript>,
  ): this is NodePath<T & t.TypeScript>;
  isTypeofTypeAnnotation<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.TypeofTypeAnnotation>,
  ): this is NodePath<T & t.TypeofTypeAnnotation>;
  isUnaryExpression<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.UnaryExpression>,
  ): this is NodePath<T & t.UnaryExpression>;
  isUnaryLike<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.UnaryLike>,
  ): this is NodePath<T & t.UnaryLike>;
  isUnionTypeAnnotation<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.UnionTypeAnnotation>,
  ): this is NodePath<T & t.UnionTypeAnnotation>;
  isUpdateExpression<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.UpdateExpression>,
  ): this is NodePath<T & t.UpdateExpression>;
  isUserWhitespacable<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.UserWhitespacable>,
  ): this is NodePath<T & t.UserWhitespacable>;
  isV8IntrinsicIdentifier<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.V8IntrinsicIdentifier>,
  ): this is NodePath<T & t.V8IntrinsicIdentifier>;
  isVariableDeclaration<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.VariableDeclaration>,
  ): this is NodePath<T & t.VariableDeclaration>;
  isVariableDeclarator<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.VariableDeclarator>,
  ): this is NodePath<T & t.VariableDeclarator>;
  isVariance<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.Variance>,
  ): this is NodePath<T & t.Variance>;
  isVoidTypeAnnotation<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.VoidTypeAnnotation>,
  ): this is NodePath<T & t.VoidTypeAnnotation>;
  isWhile<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.While>,
  ): this is NodePath<T & t.While>;
  isWhileStatement<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.WhileStatement>,
  ): this is NodePath<T & t.WhileStatement>;
  isWithStatement<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.WithStatement>,
  ): this is NodePath<T & t.WithStatement>;
  isYieldExpression<T extends t.Node>(
    this: NodePath<T>,
    opts?: Opts<t.YieldExpression>,
  ): this is NodePath<T & t.YieldExpression>;
}

interface NodePathValidators
  extends Omit<BaseNodePathValidators, keyof VirtualTypeNodePathValidators>,
    VirtualTypeNodePathValidators {}

type NodePathMixins = typeof NodePath_ancestry & typeof NodePath_inference & typeof NodePath_replacement & typeof NodePath_evaluation & typeof NodePath_conversion & typeof NodePath_introspection & typeof NodePath_context & typeof NodePath_removal & typeof NodePath_modification & typeof NodePath_family & typeof NodePath_comments;
declare class NodePath<T extends t.Node = t.Node> {
    constructor(hub: HubInterface, parent: t.ParentMaps[T["type"]]);
    parent: t.ParentMaps[T["type"]];
    hub: HubInterface;
    data: Record<string | symbol, unknown>;
    context: TraversalContext;
    scope: Scope;
    contexts: Array<TraversalContext>;
    state: any;
    opts: ExplodedTraverseOptions | null;
    _traverseFlags: number;
    skipKeys: Record<string, boolean> | null;
    parentPath: t.ParentMaps[T["type"]] extends null ? null : NodePath<t.ParentMaps[T["type"]]> | null;
    container: t.Node | Array<t.Node> | null;
    listKey: string | null;
    key: string | number | null;
    node: T;
    type: T["type"] | null;
    static get({ 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;
    getScope(scope: Scope): Scope;
    setData(key: string | symbol, val: any): any;
    getData(key: string | symbol, def?: any): any;
    hasNode(): this is NodePath<NonNullable<this["node"]>>;
    buildCodeFrameError(msg: string, Error?: new () => Error): Error;
    traverse<T>(visitor: Visitor<T>, state: T): void;
    traverse(visitor: Visitor): void;
    set(key: string, node: any): void;
    getPathLocation(): string;
    debug(message: string): void;
    toString(): string;
    get inList(): boolean;
    set inList(inList: boolean);
    get parentKey(): string;
    get shouldSkip(): boolean;
    set shouldSkip(v: boolean);
    get shouldStop(): boolean;
    set shouldStop(v: boolean);
    get removed(): boolean;
    set removed(v: boolean);
}
interface NodePath<T> extends NodePathAssertions, NodePathValidators, 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;
    }>;
}

declare let pathsCache: WeakMap<HubInterface | typeof nullHub, WeakMap<Node, Map<Node, NodePath>>>;

declare let scope: WeakMap<Node, Scope>;
declare function clear(): void;
declare function clearPath(): void;
declare function clearScope(): void;
declare const nullHub: Readonly<{}>;
declare function getCachedPaths(hub: HubInterface | null, parent: Node): Map<Node, NodePath<Node>>;
declare function getOrCreateCachedPaths(hub: HubInterface | null, parent: Node): Map<Node, NodePath<Node>>;

declare const __cache_ts_clear: typeof clear;
declare const __cache_ts_clearPath: typeof clearPath;
declare const __cache_ts_clearScope: typeof clearScope;
declare const __cache_ts_getCachedPaths: typeof getCachedPaths;
declare const __cache_ts_getOrCreateCachedPaths: typeof getOrCreateCachedPaths;
declare const __cache_ts_scope: typeof scope;
declare namespace __cache_ts {
  export { __cache_ts_clear as clear, __cache_ts_clearPath as clearPath, __cache_ts_clearScope as clearScope, __cache_ts_getCachedPaths as getCachedPaths, __cache_ts_getOrCreateCachedPaths as getOrCreateCachedPaths, pathsCache as path, __cache_ts_scope as scope };
}

type VisitWrapper<S = any> = (stateName: string | undefined, visitorType: VisitPhase, callback: VisitNodeFunction<S, Node>) => VisitNodeFunction<S, Node>;
declare function isExplodedVisitor(visitor: Visitor): visitor is ExplodedVisitor;
/**
 * explode() will take a visitor object with all of the various shorthands
 * that we support, and validates & normalizes it into a common format, ready
 * to be used in traversal
 *
 * The various shorthands are:
 * * `Identifier() { ... }` -> `Identifier: { enter() { ... } }`
 * * `"Identifier|NumericLiteral": { ... }` -> `Identifier: { ... }, NumericLiteral: { ... }`
 * * Aliases in `@babel/types`: e.g. `Property: { ... }` -> `ObjectProperty: { ... }, ClassProperty: { ... }`
 * Other normalizations are:
 * * Visitors of virtual types are wrapped, so that they are only visited when
 *   their dynamic check passes
 * * `enter` and `exit` functions are wrapped in arrays, to ease merging of
 *   visitors
 */
declare function explode<S>(visitor: Visitor<S>): ExplodedVisitor<S>;
declare function verify(visitor: Visitor): void;
declare function merge<State>(visitors: Visitor<State>[]): ExplodedVisitor<State>;
declare function merge(visitors: Visitor<unknown>[], states?: any[], wrapper?: Function | null): ExplodedVisitor<unknown>;

type __visitors_ts_VisitWrapper<S = any> = VisitWrapper<S>;
declare const __visitors_ts_explode: typeof explode;
declare const __visitors_ts_isExplodedVisitor: typeof isExplodedVisitor;
declare const __visitors_ts_merge: typeof merge;
declare const __visitors_ts_verify: typeof verify;
declare namespace __visitors_ts {
  export { type __visitors_ts_VisitWrapper as VisitWrapper, __visitors_ts_explode as explode, __visitors_ts_isExplodedVisitor as isExplodedVisitor, __visitors_ts_merge as merge, __visitors_ts_verify as verify };
}

type TraverseOptions<S = t.Node> = {
    scope?: Scope;
    noScope?: boolean;
    denylist?: string[];
    shouldSkip?: (node: NodePath) => boolean;
} & Visitor<S>;
type ExplodedTraverseOptions<S = t.Node> = TraverseOptions<S> & ExplodedVisitor<S>;
declare function traverse<S>(parent: t.Node, opts: TraverseOptions<S>, scope: Scope | undefined, state: S, parentPath?: NodePath, visitSelf?: boolean): void;
declare function traverse(parent: t.Node, opts: TraverseOptions, scope?: Scope, state?: any, parentPath?: NodePath, visitSelf?: boolean): void;
declare namespace traverse {
    var visitors: typeof __visitors_ts;
    var verify: typeof verify;
    var explode: typeof explode;
    var cheap: (node: t.Node, enter: (node: t.Node) => void) => void;
    var node: (node: t.Node, opts: ExplodedTraverseOptions<t.Node>, scope?: Scope, state?: any, path?: NodePath<t.Node>, skipKeys?: Record<string, boolean>) => void;
    var clearNode: (node: t.Node, opts?: RemovePropertiesOptions) => void;
    var removeProperties: (tree: t.Node, opts?: RemovePropertiesOptions) => t.Node;
    var hasType: (tree: t.Node, type: "AnyTypeAnnotation" | "ArgumentPlaceholder" | "ArrayExpression" | "ArrayPattern" | "ArrayTypeAnnotation" | "ArrowFunctionExpression" | "AssignmentExpression" | "AssignmentPattern" | "AwaitExpression" | "BigIntLiteral" | "BinaryExpression" | "BindExpression" | "BlockStatement" | "BooleanLiteral" | "BooleanLiteralTypeAnnotation" | "BooleanTypeAnnotation" | "BreakStatement" | "CallExpression" | "CatchClause" | "ClassAccessorProperty" | "ClassBody" | "ClassDeclaration" | "ClassExpression" | "ClassImplements" | "ClassMethod" | "ClassPrivateMethod" | "ClassPrivateProperty" | "ClassProperty" | "ConditionalExpression" | "ContinueStatement" | "DebuggerStatement" | "DecimalLiteral" | "DeclareClass" | "DeclareExportAllDeclaration" | "DeclareExportDeclaration" | "DeclareFunction" | "DeclareInterface" | "DeclareModule" | "DeclareModuleExports" | "DeclareOpaqueType" | "DeclareTypeAlias" | "DeclareVariable" | "DeclaredPredicate" | "Decorator" | "Directive" | "DirectiveLiteral" | "DoExpression" | "DoWhileStatement" | "EmptyStatement" | "EmptyTypeAnnotation" | "EnumBooleanBody" | "EnumBooleanMember" | "EnumDeclaration" | "EnumDefaultedMember" | "EnumNumberBody" | "EnumNumberMember" | "EnumStringBody" | "EnumStringMember" | "EnumSymbolBody" | "ExistsTypeAnnotation" | "ExportAllDeclaration" | "ExportDefaultDeclaration" | "ExportDefaultSpecifier" | "ExportNamedDeclaration" | "ExportNamespaceSpecifier" | "ExportSpecifier" | "ExpressionStatement" | "File" | "ForInStatement" | "ForOfStatement" | "ForStatement" | "FunctionDeclaration" | "FunctionExpression" | "FunctionTypeAnnotation" | "FunctionTypeParam" | "GenericTypeAnnotation" | "Identifier" | "IfStatement" | "Import" | "ImportAttribute" | "ImportDeclaration" | "ImportDefaultSpecifier" | "ImportExpression" | "ImportNamespaceSpecifier" | "ImportSpecifier" | "IndexedAccessType" | "InferredPredicate" | "InterfaceDeclaration" | "InterfaceExtends" | "InterfaceTypeAnnotation" | "InterpreterDirective" | "IntersectionTypeAnnotation" | "JSXAttribute" | "JSXClosingElement" | "JSXClosingFragment" | "JSXElement" | "JSXEmptyExpression" | "JSXExpressionContainer" | "JSXFragment" | "JSXIdentifier" | "JSXMemberExpression" | "JSXNamespacedName" | "JSXOpeningElement" | "JSXOpeningFragment" | "JSXSpreadAttribute" | "JSXSpreadChild" | "JSXText" | "LabeledStatement" | "LogicalExpression" | "MemberExpression" | "MetaProperty" | "MixedTypeAnnotation" | "ModuleExpression" | "NewExpression" | "Noop" | "NullLiteral" | "NullLiteralTypeAnnotation" | "NullableTypeAnnotation" | "NumberLiteral" | "NumberLiteralTypeAnnotation" | "NumberTypeAnnotation" | "NumericLiteral" | "ObjectExpression" | "ObjectMethod" | "ObjectPattern" | "ObjectProperty" | "ObjectTypeAnnotation" | "ObjectTypeCallProperty" | "ObjectTypeIndexer" | "ObjectTypeInternalSlot" | "ObjectTypeProperty" | "ObjectTypeSpreadProperty" | "OpaqueType" | "OptionalCallExpression" | "OptionalIndexedAccessType" | "OptionalMemberExpression" | "ParenthesizedExpression" | "PipelineBareFunction" | "PipelinePrimaryTopicReference" | "PipelineTopicExpression" | "Placeholder" | "PrivateName" | "Program" | "QualifiedTypeIdentifier" | "RecordExpression" | "RegExpLiteral" | "RegexLiteral" | "RestElement" | "RestProperty" | "ReturnStatement" | "SequenceExpression" | "SpreadElement" | "SpreadProperty" | "StaticBlock" | "StringLiteral" | "StringLiteralTypeAnnotation" | "StringTypeAnnotation" | "Super" | "SwitchCase" | "SwitchStatement" | "SymbolTypeAnnotation" | "TSAnyKeyword" | "TSArrayType" | "TSAsExpression" | "TSBigIntKeyword" | "TSBooleanKeyword" | "TSCallSignatureDeclaration" | "TSConditionalType" | "TSConstructSignatureDeclaration" | "TSConstructorType" | "TSDeclareFunction" | "TSDeclareMethod" | "TSEnumDeclaration" | "TSEnumMember" | "TSExportAssignment" | "TSExpressionWithTypeArguments" | "TSExternalModuleReference" | "TSFunctionType" | "TSImportEqualsDeclaration" | "TSImportType" | "TSIndexSignature" | "TSIndexedAccessType" | "TSInferType" | "TSInstantiationExpression" | "TSInterfaceBody" | "TSInterfaceDeclaration" | "TSIntersectionType" | "TSIntrinsicKeyword" | "TSLiteralType" | "TSMappedType" | "TSMethodSignature" | "TSModuleBlock" | "TSModuleDeclaration" | "TSNamedTupleMember" | "TSNamespaceExportDeclaration" | "TSNeverKeyword" | "TSNonNullExpression" | "TSNullKeyword" | "TSNumberKeyword" | "TSObjectKeyword" | "TSOptionalType" | "TSParameterProperty" | "TSParenthesizedType" | "TSPropertySignature" | "TSQualifiedName" | "TSRestType" | "TSSatisfiesExpression" | "TSStringKeyword" | "TSSymbolKeyword" | "TSThisType" | "TSTupleType" | "TSTypeAliasDeclaration" | "TSTypeAnnotation" | "TSTypeAssertion" | "TSTypeLiteral" | "TSTypeOperator" | "TSTypeParameter" | "TSTypeParameterDeclaration" | "TSTypeParameterInstantiation" | "TSTypePredicate" | "TSTypeQuery" | "TSTypeReference" | "TSUndefinedKeyword" | "TSUnionType" | "TSUnknownKeyword" | "TSVoidKeyword" | "TaggedTemplateExpression" | "TemplateElement" | "TemplateLiteral" | "ThisExpression" | "ThisTypeAnnotation" | "ThrowStatement" | "TopicReference" | "TryStatement" | "TupleExpression" | "TupleTypeAnnotation" | "TypeAlias" | "TypeAnnotation" | "TypeCastExpression" | "TypeParameter" | "TypeParameterDeclaration" | "TypeParameterInstantiation" | "TypeofTypeAnnotation" | "UnaryExpression" | "UnionTypeAnnotation" | "UpdateExpression" | "V8IntrinsicIdentifier" | "VariableDeclaration" | "VariableDeclarator" | "Variance" | "VoidTypeAnnotation" | "WhileStatement" | "WithStatement" | "YieldExpression", denylistTypes?: string[]) => boolean;
    var cache: typeof __cache_ts;
}

export { Binding, type ExplodedTraverseOptions, type ExplodedVisitor, Hub, type HubInterface, NodePath, Scope, type TraverseOptions, type Visitor, traverse as default, __visitors_ts as visitors };

[nicolo-ribaudo]

rollup-plugin-dts currently crashes on namespace objects generated by Rollup. I will open a PR upstream.

[babel-bot]

Build successful! You can test your changes in the REPL here: https://babeljs.io/repl/build/56861

[nicolo-ribaudo]

Uhm it looks like @babel/core dts is including a lot of @babel/parser internals, probably because they are not exported.

[liuxingbaoyu]

I'm not sure if we can somehow check compatibility with @types/x, specifically @babel/traverse.

There is also a long-standing problem where we cannot declare type dependencies, which may result in users having to manually install the dependencies in each type.

[liuxingbaoyu]

Let's also export Expression because there is parseExpression.

[nicolo-ribaudo]

This is because now this package has a devDependency on @babel/core@workspace (for types), but we need the root dependency to compile.

[nicolo-ribaudo]

Wow CI seems to be green (except for e2e)