babel-traverse_v7.x.x.js

/**
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * @flow
 * @format
 * @oncall react_native
 */

// The sections between BEGIN GENERATED and END GENERATED are generated
// by the updateBabelTraverseTypes.js script. You can update the sections with
// node <metro>/scripts/updateBabelTraverseTypes.js path/to/this/file

'use strict';

declare module '@babel/traverse' {
  declare export type TraverseOptions<TState> = {
    ...Visitor<TState>,
    scope?: Scope,
    noScope?: boolean,
  };

  declare export interface HubInterface {
    getCode(): ?string;
    getScope(): ?Scope;
    addHelper(name: string): {};
    buildError<TError: Error>(
      node: BabelNode,
      msg: string,
      Error: Class<TError>,
    ): TError;
  }

  declare export class Hub implements HubInterface {
    constructor(): Hub;
    getCode(): ?string;
    getScope(): ?Scope;
    addHelper(name: string): {};
    buildError<TError: Error>(
      node: BabelNode,
      msg: string,
      Error: Class<TError>,
    ): TError;
  }

  declare export interface TraversalContext {
    parentPath: NodePath<>;
    scope: Scope;
    state: any;
    opts: any;
    queue: ?Array<NodePath<>>;

    constructor(
      scope: Scope,
      opts: TraverseOptions<mixed>,
      state: any,
      parentPath: NodePath<>,
    ): TraversalContext;

    shouldVisit(node: BabelNode): boolean;
    create(
      node: BabelNode,
      obj: Array<BabelNode>,
      key: string,
      listKey: string,
    ): NodePath<>;
    maybeQueue(path: NodePath<>, notPriority?: boolean): void;
    visitMultiple(
      container: Array<BabelNode>,
      parent: BabelNode,
      listKey: string,
    ): boolean;
    visitSingle(node: BabelNode, key: string): boolean;
    visitQueue(queue: Array<NodePath<>>): boolean;
    visit(node: BabelNode, key: string): boolean;
  }

  declare export class Scope {
    static globals: Array<string>;
    static conextVariables: Array<string>;

    constructor(path: NodePath<>): Scope;
    path: NodePath<>;
    block: BabelNode;
    +labels: Map<string, NodePath<>>;
    +parentBlock: BabelNode;
    +parent: Scope;
    +hub: HubInterface;
    bindings?: {[name: string]: Binding};
    references?: {[name: string]: boolean};
    globals?: {[name: string]: BabelNode};
    uids?: {[name: string]: boolean};
    data?: {[key: string]: any};
    inited: boolean;

    /** Traverse node with current scope and path. */
    traverse<S>(
      node: BabelNode | Array<BabelNode>,
      opts: $ReadOnly<TraverseOptions<S>>,
      state: S,
    ): void;

    /** Generate a unique identifier and add it to the current scope. */
    generateDeclaredUidIdentifier(name?: string): BabelNodeIdentifier;

    /** Generate a unique identifier. */
    generateUidIdentifier(name?: string): BabelNodeIdentifier;

    /** Generate a unique `_id1` binding. */
    generateUid(name?: string): string;

    generateUidBasedOnNode(node: BabelNode, defaultName?: string): string;

    /** Generate a unique identifier based on a node. */
    generateUidIdentifierBasedOnNode(
      parent: BabelNode,
      defaultName?: string,
    ): BabelNodeIdentifier;

    /**
     * Determine whether evaluating the specific input `node` is a consequenceless reference. ie.
     * evaluating it wont result in potentially arbitrary code from being ran. The following are
     * whitelisted and determined not to cause side effects:
     *
     *  - `this` expressions
     *  - `super` expressions
     *  - Bound identifiers
     */
    isStatic(node: BabelNode): boolean;

    /** Possibly generate a memoised identifier if it is not static and has consequences. */
    maybeGenerateMemoised(
      node: BabelNode,
      dontPush?: boolean,
    ): BabelNodeIdentifier;

    checkBlockScopedCollisions(
      local: BabelNode,
      kind: string,
      name: string,
      id: {},
    ): void;

    rename(oldName: string, newName?: string, block?: BabelNode): void;

    dump(): void;

    toArray(
      node: BabelNode,
      i?: number | boolean,
      allowArrayLike?: boolean,
    ): BabelNode;

    hasLabel(name: string): boolean;

    getLabel(name: string): NodePath<>;

    registerLabel(path: NodePath<>): void;

    registerDeclaration(path: NodePath<>): void;

    buildUndefinedNode(): BabelNode;

    registerConstantViolation(path: NodePath<>): void;

    registerBinding(
      kind: BindingKind,
      path: NodePath<>,
      bindingPath?: NodePath<>,
    ): void;

    addGlobal(node: BabelNode): void;

    hasUid(name: string): boolean;

    hasGlobal(name: string): boolean;

    hasReference(name: string): boolean;

    isPure(node: BabelNode, constantsOnly?: boolean): boolean;

    /**
     * Set some arbitrary data on the current scope.
     */
    setData(key: string, val: any): any;

    /**
     * Recursively walk up scope tree looking for the data `key`.
     */
    getData(key: string): 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: BabelNodeLVal,
      init?: BabelNodeExpression,
      unique?: boolean,
      _blockHoist?: ?number,
      kind?: 'var' | 'let',
    }): void;

    getProgramParent(): Scope;

    getFunctionParent(): Scope | null;

    getBlockParent(): Scope;

    /** Walks the scope tree and gathers **all** bindings. */
    getAllBindings(): {[name: string]: Binding};

    getAllBindingsOfKind(...kind: Array<BindingKind>): {
      [name: string]: Binding,
    };

    bindingIdentifierEquals(name: string, node: BabelNode): boolean;

    getBinding(name: string): Binding | void;

    getOwnBinding(name: string): Binding | void;

    getBindingIdentifier(name: string): BabelNodeIdentifier | void;

    getOwnBindingIdentifier(name: string): BabelNodeIdentifier | void;

    hasOwnBinding(name: string): boolean;

    hasBinding(name: string, noGlobals?: boolean): boolean;

    parentHasBinding(name: string, noGlobals?: boolean): boolean;

    /** Move a binding of `name` to another `scope`. */
    moveBindingTo(name: string, scope: Scope): void;

    removeOwnBinding(name: string): void;

    removeBinding(name: string): void;
  }

  declare export type BindingKind =
    | 'var'
    | 'let'
    | 'const'
    | 'module'
    | 'hoisted'
    | 'unknown';

  declare export class Binding {
    constructor(opts: {
      identifier: BabelNodeIdentifier,
      scope: Scope,
      path: NodePath<>,
      kind: BindingKind,
    }): Binding;
    identifier: BabelNodeIdentifier;
    scope: Scope;
    path: NodePath<>;
    kind: BindingKind;
    referenced: boolean;
    references: number;
    referencePaths: Array<NodePath<>>;
    constant: boolean;
    constantViolations: Array<NodePath<>>;
    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;

    dereference(): void;
  }

  declare type Opts = {...};

  declare export class NodePath<+TNode: BabelNode = BabelNode> {
    parent: BabelNode;
    hub: HubInterface;
    contexts: Array<TraversalContext>;
    data: {[key: string]: mixed} | null;
    shouldSkip: boolean;
    shouldStop: boolean;
    removed: boolean;
    state: mixed;
    +opts: $ReadOnly<TraverseOptions<mixed>> | null;
    skipKeys: null | {[key: string]: boolean};
    parentPath: ?NodePath<>;
    context: TraversalContext;
    container: null | {...} | Array<{...}>;
    listKey: null | string;
    key: null | string;

    /* Declaring node as readonly isn't entirely correct since the node can be
     * changed by e.g. calling replaceWith. However, this is needed to reasonably
     * work with `NodePath`, e.g. that passing `NodePath<CallExpression>` to a
     * `NodePath<Node> works.
     */
    +node: TNode;

    parentKey: string;
    scope: Scope;
    type: null | BabelNode['type'];
    inList: boolean;
    typeAnnotation?: BabelNodeTypeAnnotation;

    constructor(hub: HubInterface, parent: BabelNode): NodePath<TNode>;

    static get({
      hub: HubInterface,
      parentPath: ?NodePath<>,
      parent: BabelNode,
      container: null | {...} | Array<{...}>,
      listKey: null | string,
      key: null | string,
    }): NodePath<>;

    getScope(scope: Scope): Scope;

    setData<TVal>(key: string, val: TVal): TVal;
    getData<TVal = mixed>(key: string, def?: TVal): TVal;

    buildCodeFrameError<TError: Error>(
      msg: string,
      Error?: Class<TError>,
    ): TError;

    traverse<TState>(
      visitor: $ReadOnly<TraverseOptions<TState>>,
      state: TState,
    ): void;

    set(key: string, node: BabelNode): void;
    getPathLocation(): string;

    debug(message: string): void;

    toString(): string;

    // _ancestry
    /**
     * 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.
     */
    findParent(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.
     */
    find(callback: (path: NodePath<>) => boolean): NodePath<> | null;

    /**
     * Get the parent function of the current path.
     */
    getFunctionParent(): NodePath<BabelNodeFunction> | null;

    /**
     * Walk up the tree until we hit a parent node path in a list.
     */
    getStatementParent(): NodePath<BabelNodeStatement>;

    /**
     * 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.
     */
    getEarliestCommonAncestorFrom(
      paths: $ReadOnlyArray<NodePath<>>,
    ): NodePath<>;

    /**
     * Get the earliest path in the tree where the provided `paths` intersect.
     *
     * TODO: Possible optimisation target.
     */
    getDeepestCommonAncestorFrom(
      paths: $ReadOnlyArray<NodePath<>>,
      filter?: (
        lastCommon: BabelNode,
        lastCommonIndex: number,
        ancestries: Array<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.
     */
    getAncestry(): Array<NodePath<>>;

    /**
     * A helper to find if `this` path is an ancestor of @param maybeDescendant
     */
    isAncestor(maybeDescendant: NodePath<>): boolean;

    /**
     * A helper to find if `this` path is a descendant of @param maybeAncestor
     */
    isDescendant(maybeAncestor: NodePath<>): boolean;

    inType(...candidateTypes: Array<BabelNode['type']>): boolean;

    // _inference

    /**
     * Infer the type of the current `NodePath`.
     */
    getTypeAnnotation(): BabelNodeTypeAnnotation;

    isBaseType(baseName: string, soft?: boolean): boolean;
    couldBeBaseType(
      name:
        | 'string'
        | 'number'
        | 'boolean'
        | 'any'
        | 'mixed'
        | 'empty'
        | 'void',
    ): boolean;
    baseTypeStrictlyMatches(right: NodePath<>): ?boolean;
    isGenericType(genericName: string): boolean;

    // _replacement

    /**
     * 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.
     */
    replaceWithMultiple(node: Array<BabelNode>): Array<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.
     */
    replaceWithSourceString(replacement: string): Array<NodePath<>>;

    /**
     * Replace the current node with another.
     */
    replaceWith(replacement: BabelNode | NodePath<>): Array<NodePath<>>;

    /**
     * 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.
     */
    replaceExpressionWithStatement(
      nodes: Array<BabelNodeStatement>,
    ): Array<NodePath<>>;

    replaceInline(nodes: BabelNode | Array<BabelNode>): Array<NodePath<>>;

    // _evaluation

    /**
     * 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();
     *
     */
    evaluateTruthy(): boolean | void;

    /**
     * Walk the input `node` and statically evaluate it.
     *
     * Returns an object in the form `{ confident, value }`. `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.
     *
     * 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 }
     *
     */
    evaluate():
      | {confident: true, value: any, deopt: null}
      | {confident: false, value: void, deopt: NodePath<>};

    // conversion
    toComputedKey(): BabelNode;

    ensureBlock(): BabelNode;

    /**
     * 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.
     */
    unwrapFunctionEnvironment(): void;

    /**
     * Convert a given arrow function into a normal ES5 function expression.
     */
    arrowFunctionToExpression(options?: {
      allowInsertArrow?: boolean,
      specCompliant?: boolean,
    }): void;

    // introspection

    /**
     * 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"]`.
     */
    matchesPattern(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.
     */
    has(key: $Keys<TNode>): boolean;

    isStatic(): boolean;

    /**
     * Alias of `has`.
     */
    is(key: $Keys<TNode>): boolean;

    /**
     * Opposite of `has`.
     */
    isnt(key: $Keys<TNode>): boolean;

    /**
     * Check whether the path node `key` strict equals `value`.
     */
    equals(key: $Keys<TNode>, 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.
     */
    isNodeType(type: BabelNode['type']): 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.
     */
    canHaveVariableDeclarationOrExpression(): 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.
     */
    canSwapBetweenExpressionAndStatement(replacement: BabelNode): boolean;

    /**
     * Check whether the current path references a completion record
     */
    isCompletionRecord(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.
     */
    isStatementOrBlock(): boolean;

    /**
     * Check if the currently assigned path references the `importName` of `moduleSource`.
     */
    referencesImport(moduleSource: string, importName?: string): boolean;

    /**
     * Get the source code associated with this node.
     */
    getSource(): string;

    willIMaybeExecuteBefore(target: NodePath<>): boolean;

    /**
     * Resolve a "pointer" `NodePath` to it's absolute path.
     */
    resolve(dangerous?: boolean, resolved?: Array<NodePath<>>): NodePath<>;

    isConstantExpression(): boolean;

    isInStrictMode(): boolean;

    // context
    call(key: string): boolean;

    isBlacklisted(): boolean;

    visit(): boolean;

    skip(): boolean;

    skipKey(key: string): boolean;

    stop(): void;

    setScope(): void;

    setContext(context: TraversalContext): NodePath<TNode>;

    /**
     * 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.
     */
    resync(): void;

    popContext(): void;

    pushContext(context: TraversalContext): void;

    setup(
      parentPath: NodePath<>,
      container: ?{...} | ?Array<{...}>,
      listKey: string,
      key: string,
    ): void;

    setKey(key: string): void;

    requeue(pathToQueue?: NodePath<>): void;

    // removal
    remove(): void;

    // modification

    /**
     * Insert the provided nodes before the current one.
     */
    insertBefore(nodes: BabelNode | Array<BabelNode>): Array<NodePath<>>;

    /**
     * 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.
     */
    insertAfter(nodes: BabelNode | Array<BabelNode>): Array<NodePath<>>;

    /**
     * Update all sibling node paths after `fromIndex` by `incrementBy`.
     */
    updateSiblingKeys(fromIndex: number, incrementBy: number): void;

    unshiftContainer(
      listKey: string,
      nodes: BabelNode | Array<BabelNode>,
    ): Array<NodePath<>>;

    pushContainer(
      listKey: string,
      nodes: BabelNode | Array<BabelNode>,
    ): Array<NodePath<>>;

    /**
     * Hoist the current node to the highest scope possible and return a UID
     * referencing it.
     */
    hoist(scope?: Scope): ?NodePath<>;

    // family
    getOpposite(): ?NodePath<>;

    getCompletionRecords(): Array<NodePath<>>;

    getSibling(key: string): NodePath<>;

    getPrevSibling(): NodePath<>;

    getNextSibling(): NodePath<>;

    getAllNextSiblings(): Array<NodePath<>>;

    getAllPrevSiblings(): Array<NodePath<>>;

    get<TKey: $Keys<TNode>>(
      key: TKey,
      context?: boolean | TraversalContext,
    ): TNode[TKey] extends BabelNode ? NodePath<> : Array<NodePath<>>;

    get(
      key: string,
      context?: boolean | TraversalContext,
    ): NodePath<> | Array<NodePath<>>;

    getBindingIdentifiers(duplicates?: void | false): {
      [key: string]: BabelNodeIdentifier,
    };

    getBindingIdentifiers(duplicates: true): {
      [key: string]: Array<BabelNodeIdentifier>,
    };

    getOuterBindingIdentifiers(duplicates: true): {
      [key: string]: Array<BabelNodeIdentifier>,
    };
    getOuterBindingIdentifiers(duplicates?: false): {
      [key: string]: BabelNodeIdentifier,
    };
    getOuterBindingIdentifiers(duplicates: boolean): {
      [key: string]: BabelNodeIdentifier | Array<BabelNodeIdentifier>,
    };

    getBindingIdentifierPaths(
      duplicates?: void | false,
      outerOnly?: boolean,
    ): {[key: string]: NodePath<BabelNodeIdentifier>};

    getBindingIdentifierPaths(
      duplicates: true,
      outerOnly?: boolean,
    ): {[key: string]: Array<NodePath<BabelNodeIdentifier>>};

    getOuterBindingIdentifierPaths(duplicates?: void | false): {
      [key: string]: NodePath<BabelNodeIdentifier>,
    };

    getOuterBindingIdentifierPaths(duplicates: true): {
      [key: string]: Array<NodePath<BabelNodeIdentifier>>,
    };

    // comments
    shareCommentsWithSiblings(): void;

    addComment(
      type: 'leading' | 'inner' | 'trailing',
      content: string,
      line?: boolean,
    ): void;

    addComments(
      type: 'leading' | 'inner' | 'trailing',
      comments: Array<BabelNodeComment>,
    ): void;

    // This section is automatically generated. Don't edit by hand.
    // See the comment at the top of the file on how to update the definitions.
    // BEGIN GENERATED NODE PATH METHODS
    isAccessor(opts?: Opts): boolean;
    isAnyTypeAnnotation(opts?: Opts): boolean;
    isArgumentPlaceholder(opts?: Opts): boolean;
    isArrayExpression(opts?: Opts): boolean;
    isArrayPattern(opts?: Opts): boolean;
    isArrayTypeAnnotation(opts?: Opts): boolean;
    isArrowFunctionExpression(opts?: Opts): boolean;
    isAssignmentExpression(opts?: Opts): boolean;
    isAssignmentPattern(opts?: Opts): boolean;
    isAwaitExpression(opts?: Opts): boolean;
    isBigIntLiteral(opts?: Opts): boolean;
    isBinary(opts?: Opts): boolean;
    isBinaryExpression(opts?: Opts): boolean;
    isBindExpression(opts?: Opts): boolean;
    isBindingIdentifier(opts?: Opts): boolean;
    isBlock(opts?: Opts): boolean;
    isBlockParent(opts?: Opts): boolean;
    isBlockScoped(opts?: Opts): boolean;
    isBlockStatement(opts?: Opts): boolean;
    isBooleanLiteral(opts?: Opts): boolean;
    isBooleanLiteralTypeAnnotation(opts?: Opts): boolean;
    isBooleanTypeAnnotation(opts?: Opts): boolean;
    isBreakStatement(opts?: Opts): boolean;
    isCallExpression(opts?: Opts): boolean;
    isCatchClause(opts?: Opts): boolean;
    isClass(opts?: Opts): boolean;
    isClassAccessorProperty(opts?: Opts): boolean;
    isClassBody(opts?: Opts): boolean;
    isClassDeclaration(opts?: Opts): boolean;
    isClassExpression(opts?: Opts): boolean;
    isClassImplements(opts?: Opts): boolean;
    isClassMethod(opts?: Opts): boolean;
    isClassPrivateMethod(opts?: Opts): boolean;
    isClassPrivateProperty(opts?: Opts): boolean;
    isClassProperty(opts?: Opts): boolean;
    isCompletionStatement(opts?: Opts): boolean;
    isConditional(opts?: Opts): boolean;
    isConditionalExpression(opts?: Opts): boolean;
    isContinueStatement(opts?: Opts): boolean;
    isDebuggerStatement(opts?: Opts): boolean;
    isDecimalLiteral(opts?: Opts): boolean;
    isDeclaration(opts?: Opts): boolean;
    isDeclareClass(opts?: Opts): boolean;
    isDeclareExportAllDeclaration(opts?: Opts): boolean;
    isDeclareExportDeclaration(opts?: Opts): boolean;
    isDeclareFunction(opts?: Opts): boolean;
    isDeclareInterface(opts?: Opts): boolean;
    isDeclareModule(opts?: Opts): boolean;
    isDeclareModuleExports(opts?: Opts): boolean;
    isDeclareOpaqueType(opts?: Opts): boolean;
    isDeclareTypeAlias(opts?: Opts): boolean;
    isDeclareVariable(opts?: Opts): boolean;
    isDeclaredPredicate(opts?: Opts): boolean;
    isDecorator(opts?: Opts): boolean;
    isDirective(opts?: Opts): boolean;
    isDirectiveLiteral(opts?: Opts): boolean;
    isDoExpression(opts?: Opts): boolean;
    isDoWhileStatement(opts?: Opts): boolean;
    isEmptyStatement(opts?: Opts): boolean;
    isEmptyTypeAnnotation(opts?: Opts): boolean;
    isEnumBody(opts?: Opts): boolean;
    isEnumBooleanBody(opts?: Opts): boolean;
    isEnumBooleanMember(opts?: Opts): boolean;
    isEnumDeclaration(opts?: Opts): boolean;
    isEnumDefaultedMember(opts?: Opts): boolean;
    isEnumMember(opts?: Opts): boolean;
    isEnumNumberBody(opts?: Opts): boolean;
    isEnumNumberMember(opts?: Opts): boolean;
    isEnumStringBody(opts?: Opts): boolean;
    isEnumStringMember(opts?: Opts): boolean;
    isEnumSymbolBody(opts?: Opts): boolean;
    isExistentialTypeParam(opts?: Opts): boolean;
    isExistsTypeAnnotation(opts?: Opts): boolean;
    isExportAllDeclaration(opts?: Opts): boolean;
    isExportDeclaration(opts?: Opts): boolean;
    isExportDefaultDeclaration(opts?: Opts): boolean;
    isExportDefaultSpecifier(opts?: Opts): boolean;
    isExportNamedDeclaration(opts?: Opts): boolean;
    isExportNamespaceSpecifier(opts?: Opts): boolean;
    isExportSpecifier(opts?: Opts): boolean;
    isExpression(opts?: Opts): boolean;
    isExpressionStatement(opts?: Opts): boolean;
    isExpressionWrapper(opts?: Opts): boolean;
    isFile(opts?: Opts): boolean;
    isFlow(opts?: Opts): boolean;
    isFlowBaseAnnotation(opts?: Opts): boolean;
    isFlowDeclaration(opts?: Opts): boolean;
    isFlowPredicate(opts?: Opts): boolean;
    isFlowType(opts?: Opts): boolean;
    isFor(opts?: Opts): boolean;
    isForAwaitStatement(opts?: Opts): boolean;
    isForInStatement(opts?: Opts): boolean;
    isForOfStatement(opts?: Opts): boolean;
    isForStatement(opts?: Opts): boolean;
    isForXStatement(opts?: Opts): boolean;
    isFunction(opts?: Opts): boolean;
    isFunctionDeclaration(opts?: Opts): boolean;
    isFunctionExpression(opts?: Opts): boolean;
    isFunctionParent(opts?: Opts): boolean;
    isFunctionTypeAnnotation(opts?: Opts): boolean;
    isFunctionTypeParam(opts?: Opts): boolean;
    isGenerated(opts?: Opts): boolean;
    isGenericTypeAnnotation(opts?: Opts): boolean;
    isIdentifier(opts?: Opts): boolean;
    isIfStatement(opts?: Opts): boolean;
    isImmutable(opts?: Opts): boolean;
    isImport(opts?: Opts): boolean;
    isImportAttribute(opts?: Opts): boolean;
    isImportDeclaration(opts?: Opts): boolean;
    isImportDefaultSpecifier(opts?: Opts): boolean;
    isImportNamespaceSpecifier(opts?: Opts): boolean;
    isImportSpecifier(opts?: Opts): boolean;
    isIndexedAccessType(opts?: Opts): boolean;
    isInferredPredicate(opts?: Opts): boolean;
    isInterfaceDeclaration(opts?: Opts): boolean;
    isInterfaceExtends(opts?: Opts): boolean;
    isInterfaceTypeAnnotation(opts?: Opts): boolean;
    isInterpreterDirective(opts?: Opts): boolean;
    isIntersectionTypeAnnotation(opts?: Opts): boolean;
    isJSX(opts?: Opts): boolean;
    isJSXAttribute(opts?: Opts): boolean;
    isJSXClosingElement(opts?: Opts): boolean;
    isJSXClosingFragment(opts?: Opts): boolean;
    isJSXElement(opts?: Opts): boolean;
    isJSXEmptyExpression(opts?: Opts): boolean;
    isJSXExpressionContainer(opts?: Opts): boolean;
    isJSXFragment(opts?: Opts): boolean;
    isJSXIdentifier(opts?: Opts): boolean;
    isJSXMemberExpression(opts?: Opts): boolean;
    isJSXNamespacedName(opts?: Opts): boolean;
    isJSXOpeningElement(opts?: Opts): boolean;
    isJSXOpeningFragment(opts?: Opts): boolean;
    isJSXSpreadAttribute(opts?: Opts): boolean;
    isJSXSpreadChild(opts?: Opts): boolean;
    isJSXText(opts?: Opts): boolean;
    isLVal(opts?: Opts): boolean;
    isLabeledStatement(opts?: Opts): boolean;
    isLiteral(opts?: Opts): boolean;
    isLogicalExpression(opts?: Opts): boolean;
    isLoop(opts?: Opts): boolean;
    isMemberExpression(opts?: Opts): boolean;
    isMetaProperty(opts?: Opts): boolean;
    isMethod(opts?: Opts): boolean;
    isMiscellaneous(opts?: Opts): boolean;
    isMixedTypeAnnotation(opts?: Opts): boolean;
    isModuleDeclaration(opts?: Opts): boolean;
    isModuleExpression(opts?: Opts): boolean;
    isModuleSpecifier(opts?: Opts): boolean;
    isNewExpression(opts?: Opts): boolean;
    isNoop(opts?: Opts): boolean;
    isNullLiteral(opts?: Opts): boolean;
    isNullLiteralTypeAnnotation(opts?: Opts): boolean;
    isNullableTypeAnnotation(opts?: Opts): boolean;
    isNumberLiteral(opts?: Opts): boolean;
    isNumberLiteralTypeAnnotation(opts?: Opts): boolean;
    isNumberTypeAnnotation(opts?: Opts): boolean;
    isNumericLiteral(opts?: Opts): boolean;
    isNumericLiteralTypeAnnotation(opts?: Opts): boolean;
    isObjectExpression(opts?: Opts): boolean;
    isObjectMember(opts?: Opts): boolean;
    isObjectMethod(opts?: Opts): boolean;
    isObjectPattern(opts?: Opts): boolean;
    isObjectProperty(opts?: Opts): boolean;
    isObjectTypeAnnotation(opts?: Opts): boolean;
    isObjectTypeCallProperty(opts?: Opts): boolean;
    isObjectTypeIndexer(opts?: Opts): boolean;
    isObjectTypeInternalSlot(opts?: Opts): boolean;
    isObjectTypeProperty(opts?: Opts): boolean;
    isObjectTypeSpreadProperty(opts?: Opts): boolean;
    isOpaqueType(opts?: Opts): boolean;
    isOptionalCallExpression(opts?: Opts): boolean;
    isOptionalIndexedAccessType(opts?: Opts): boolean;
    isOptionalMemberExpression(opts?: Opts): boolean;
    isParenthesizedExpression(opts?: Opts): boolean;
    isPattern(opts?: Opts): boolean;
    isPatternLike(opts?: Opts): boolean;
    isPipelineBareFunction(opts?: Opts): boolean;
    isPipelinePrimaryTopicReference(opts?: Opts): boolean;
    isPipelineTopicExpression(opts?: Opts): boolean;
    isPlaceholder(opts?: Opts): boolean;
    isPrivate(opts?: Opts): boolean;
    isPrivateName(opts?: Opts): boolean;
    isProgram(opts?: Opts): boolean;
    isProperty(opts?: Opts): boolean;
    isPure(opts?: Opts): boolean;
    isPureish(opts?: Opts): boolean;
    isQualifiedTypeIdentifier(opts?: Opts): boolean;
    isRecordExpression(opts?: Opts): boolean;
    isReferenced(opts?: Opts): boolean;
    isReferencedIdentifier(opts?: Opts): boolean;
    isReferencedMemberExpression(opts?: Opts): boolean;
    isRegExpLiteral(opts?: Opts): boolean;
    isRegexLiteral(opts?: Opts): boolean;
    isRestElement(opts?: Opts): boolean;
    isRestProperty(opts?: Opts): boolean;
    isReturnStatement(opts?: Opts): boolean;
    isScopable(opts?: Opts): boolean;
    isScope(opts?: Opts): boolean;
    isSequenceExpression(opts?: Opts): boolean;
    isSpreadElement(opts?: Opts): boolean;
    isSpreadProperty(opts?: Opts): boolean;
    isStandardized(opts?: Opts): boolean;
    isStatement(opts?: Opts): boolean;
    isStaticBlock(opts?: Opts): boolean;
    isStringLiteral(opts?: Opts): boolean;
    isStringLiteralTypeAnnotation(opts?: Opts): boolean;
    isStringTypeAnnotation(opts?: Opts): boolean;
    isSuper(opts?: Opts): boolean;
    isSwitchCase(opts?: Opts): boolean;
    isSwitchStatement(opts?: Opts): boolean;
    isSymbolTypeAnnotation(opts?: Opts): boolean;
    isTSAnyKeyword(opts?: Opts): boolean;
    isTSArrayType(opts?: Opts): boolean;
    isTSAsExpression(opts?: Opts): boolean;
    isTSBaseType(opts?: Opts): boolean;
    isTSBigIntKeyword(opts?: Opts): boolean;
    isTSBooleanKeyword(opts?: Opts): boolean;
    isTSCallSignatureDeclaration(opts?: Opts): boolean;
    isTSConditionalType(opts?: Opts): boolean;
    isTSConstructSignatureDeclaration(opts?: Opts): boolean;
    isTSConstructorType(opts?: Opts): boolean;
    isTSDeclareFunction(opts?: Opts): boolean;
    isTSDeclareMethod(opts?: Opts): boolean;
    isTSEntityName(opts?: Opts): boolean;
    isTSEnumDeclaration(opts?: Opts): boolean;
    isTSEnumMember(opts?: Opts): boolean;
    isTSExportAssignment(opts?: Opts): boolean;
    isTSExpressionWithTypeArguments(opts?: Opts): boolean;
    isTSExternalModuleReference(opts?: Opts): boolean;
    isTSFunctionType(opts?: Opts): boolean;
    isTSImportEqualsDeclaration(opts?: Opts): boolean;
    isTSImportType(opts?: Opts): boolean;
    isTSIndexSignature(opts?: Opts): boolean;
    isTSIndexedAccessType(opts?: Opts): boolean;
    isTSInferType(opts?: Opts): boolean;
    isTSInstantiationExpression(opts?: Opts): boolean;
    isTSInterfaceBody(opts?: Opts): boolean;
    isTSInterfaceDeclaration(opts?: Opts): boolean;
    isTSIntersectionType(opts?: Opts): boolean;
    isTSIntrinsicKeyword(opts?: Opts): boolean;
    isTSLiteralType(opts?: Opts): boolean;
    isTSMappedType(opts?: Opts): boolean;
    isTSMethodSignature(opts?: Opts): boolean;
    isTSModuleBlock(opts?: Opts): boolean;
    isTSModuleDeclaration(opts?: Opts): boolean;
    isTSNamedTupleMember(opts?: Opts): boolean;
    isTSNamespaceExportDeclaration(opts?: Opts): boolean;
    isTSNeverKeyword(opts?: Opts): boolean;
    isTSNonNullExpression(opts?: Opts): boolean;
    isTSNullKeyword(opts?: Opts): boolean;
    isTSNumberKeyword(opts?: Opts): boolean;
    isTSObjectKeyword(opts?: Opts): boolean;
    isTSOptionalType(opts?: Opts): boolean;
    isTSParameterProperty(opts?: Opts): boolean;
    isTSParenthesizedType(opts?: Opts): boolean;
    isTSPropertySignature(opts?: Opts): boolean;
    isTSQualifiedName(opts?: Opts): boolean;
    isTSRestType(opts?: Opts): boolean;
    isTSSatisfiesExpression(opts?: Opts): boolean;
    isTSStringKeyword(opts?: Opts): boolean;
    isTSSymbolKeyword(opts?: Opts): boolean;
    isTSThisType(opts?: Opts): boolean;
    isTSTupleType(opts?: Opts): boolean;
    isTSType(opts?: Opts): boolean;
    isTSTypeAliasDeclaration(opts?: Opts): boolean;
    isTSTypeAnnotation(opts?: Opts): boolean;
    isTSTypeAssertion(opts?: Opts): boolean;
    isTSTypeElement(opts?: Opts): boolean;
    isTSTypeLiteral(opts?: Opts): boolean;
    isTSTypeOperator(opts?: Opts): boolean;
    isTSTypeParameter(opts?: Opts): boolean;
    isTSTypeParameterDeclaration(opts?: Opts): boolean;
    isTSTypeParameterInstantiation(opts?: Opts): boolean;
    isTSTypePredicate(opts?: Opts): boolean;
    isTSTypeQuery(opts?: Opts): boolean;
    isTSTypeReference(opts?: Opts): boolean;
    isTSUndefinedKeyword(opts?: Opts): boolean;
    isTSUnionType(opts?: Opts): boolean;
    isTSUnknownKeyword(opts?: Opts): boolean;
    isTSVoidKeyword(opts?: Opts): boolean;
    isTaggedTemplateExpression(opts?: Opts): boolean;
    isTemplateElement(opts?: Opts): boolean;
    isTemplateLiteral(opts?: Opts): boolean;
    isTerminatorless(opts?: Opts): boolean;
    isThisExpression(opts?: Opts): boolean;
    isThisTypeAnnotation(opts?: Opts): boolean;
    isThrowStatement(opts?: Opts): boolean;
    isTopicReference(opts?: Opts): boolean;
    isTryStatement(opts?: Opts): boolean;
    isTupleExpression(opts?: Opts): boolean;
    isTupleTypeAnnotation(opts?: Opts): boolean;
    isTypeAlias(opts?: Opts): boolean;
    isTypeAnnotation(opts?: Opts): boolean;
    isTypeCastExpression(opts?: Opts): boolean;
    isTypeParameter(opts?: Opts): boolean;
    isTypeParameterDeclaration(opts?: Opts): boolean;
    isTypeParameterInstantiation(opts?: Opts): boolean;
    isTypeScript(opts?: Opts): boolean;
    isTypeofTypeAnnotation(opts?: Opts): boolean;
    isUnaryExpression(opts?: Opts): boolean;
    isUnaryLike(opts?: Opts): boolean;
    isUnionTypeAnnotation(opts?: Opts): boolean;
    isUpdateExpression(opts?: Opts): boolean;
    isUser(opts?: Opts): boolean;
    isUserWhitespacable(opts?: Opts): boolean;
    isV8IntrinsicIdentifier(opts?: Opts): boolean;
    isVar(opts?: Opts): boolean;
    isVariableDeclaration(opts?: Opts): boolean;
    isVariableDeclarator(opts?: Opts): boolean;
    isVariance(opts?: Opts): boolean;
    isVoidTypeAnnotation(opts?: Opts): boolean;
    isWhile(opts?: Opts): boolean;
    isWhileStatement(opts?: Opts): boolean;
    isWithStatement(opts?: Opts): boolean;
    isYieldExpression(opts?: Opts): boolean;
    assertAccessor(opts?: Opts): void;
    assertAnyTypeAnnotation(opts?: Opts): void;
    assertArgumentPlaceholder(opts?: Opts): void;
    assertArrayExpression(opts?: Opts): void;
    assertArrayPattern(opts?: Opts): void;
    assertArrayTypeAnnotation(opts?: Opts): void;
    assertArrowFunctionExpression(opts?: Opts): void;
    assertAssignmentExpression(opts?: Opts): void;
    assertAssignmentPattern(opts?: Opts): void;
    assertAwaitExpression(opts?: Opts): void;
    assertBigIntLiteral(opts?: Opts): void;
    assertBinary(opts?: Opts): void;
    assertBinaryExpression(opts?: Opts): void;
    assertBindExpression(opts?: Opts): void;
    assertBindingIdentifier(opts?: Opts): void;
    assertBlock(opts?: Opts): void;
    assertBlockParent(opts?: Opts): void;
    assertBlockScoped(opts?: Opts): void;
    assertBlockStatement(opts?: Opts): void;
    assertBooleanLiteral(opts?: Opts): void;
    assertBooleanLiteralTypeAnnotation(opts?: Opts): void;
    assertBooleanTypeAnnotation(opts?: Opts): void;
    assertBreakStatement(opts?: Opts): void;
    assertCallExpression(opts?: Opts): void;
    assertCatchClause(opts?: Opts): void;
    assertClass(opts?: Opts): void;
    assertClassAccessorProperty(opts?: Opts): void;
    assertClassBody(opts?: Opts): void;
    assertClassDeclaration(opts?: Opts): void;
    assertClassExpression(opts?: Opts): void;
    assertClassImplements(opts?: Opts): void;
    assertClassMethod(opts?: Opts): void;
    assertClassPrivateMethod(opts?: Opts): void;
    assertClassPrivateProperty(opts?: Opts): void;
    assertClassProperty(opts?: Opts): void;
    assertCompletionStatement(opts?: Opts): void;
    assertConditional(opts?: Opts): void;
    assertConditionalExpression(opts?: Opts): void;
    assertContinueStatement(opts?: Opts): void;
    assertDebuggerStatement(opts?: Opts): void;
    assertDecimalLiteral(opts?: Opts): void;
    assertDeclaration(opts?: Opts): void;
    assertDeclareClass(opts?: Opts): void;
    assertDeclareExportAllDeclaration(opts?: Opts): void;
    assertDeclareExportDeclaration(opts?: Opts): void;
    assertDeclareFunction(opts?: Opts): void;
    assertDeclareInterface(opts?: Opts): void;
    assertDeclareModule(opts?: Opts): void;
    assertDeclareModuleExports(opts?: Opts): void;
    assertDeclareOpaqueType(opts?: Opts): void;
    assertDeclareTypeAlias(opts?: Opts): void;
    assertDeclareVariable(opts?: Opts): void;
    assertDeclaredPredicate(opts?: Opts): void;
    assertDecorator(opts?: Opts): void;
    assertDirective(opts?: Opts): void;
    assertDirectiveLiteral(opts?: Opts): void;
    assertDoExpression(opts?: Opts): void;
    assertDoWhileStatement(opts?: Opts): void;
    assertEmptyStatement(opts?: Opts): void;
    assertEmptyTypeAnnotation(opts?: Opts): void;
    assertEnumBody(opts?: Opts): void;
    assertEnumBooleanBody(opts?: Opts): void;
    assertEnumBooleanMember(opts?: Opts): void;
    assertEnumDeclaration(opts?: Opts): void;
    assertEnumDefaultedMember(opts?: Opts): void;
    assertEnumMember(opts?: Opts): void;
    assertEnumNumberBody(opts?: Opts): void;
    assertEnumNumberMember(opts?: Opts): void;
    assertEnumStringBody(opts?: Opts): void;
    assertEnumStringMember(opts?: Opts): void;
    assertEnumSymbolBody(opts?: Opts): void;
    assertExistentialTypeParam(opts?: Opts): void;
    assertExistsTypeAnnotation(opts?: Opts): void;
    assertExportAllDeclaration(opts?: Opts): void;
    assertExportDeclaration(opts?: Opts): void;
    assertExportDefaultDeclaration(opts?: Opts): void;
    assertExportDefaultSpecifier(opts?: Opts): void;
    assertExportNamedDeclaration(opts?: Opts): void;
    assertExportNamespaceSpecifier(opts?: Opts): void;
    assertExportSpecifier(opts?: Opts): void;
    assertExpression(opts?: Opts): void;
    assertExpressionStatement(opts?: Opts): void;
    assertExpressionWrapper(opts?: Opts): void;
    assertFile(opts?: Opts): void;
    assertFlow(opts?: Opts): void;
    assertFlowBaseAnnotation(opts?: Opts): void;
    assertFlowDeclaration(opts?: Opts): void;
    assertFlowPredicate(opts?: Opts): void;
    assertFlowType(opts?: Opts): void;
    assertFor(opts?: Opts): void;
    assertForAwaitStatement(opts?: Opts): void;
    assertForInStatement(opts?: Opts): void;
    assertForOfStatement(opts?: Opts): void;
    assertForStatement(opts?: Opts): void;
    assertForXStatement(opts?: Opts): void;
    assertFunction(opts?: Opts): void;
    assertFunctionDeclaration(opts?: Opts): void;
    assertFunctionExpression(opts?: Opts): void;
    assertFunctionParent(opts?: Opts): void;
    assertFunctionTypeAnnotation(opts?: Opts): void;
    assertFunctionTypeParam(opts?: Opts): void;
    assertGenerated(opts?: Opts): void;
    assertGenericTypeAnnotation(opts?: Opts): void;
    assertIdentifier(opts?: Opts): void;
    assertIfStatement(opts?: Opts): void;
    assertImmutable(opts?: Opts): void;
    assertImport(opts?: Opts): void;
    assertImportAttribute(opts?: Opts): void;
    assertImportDeclaration(opts?: Opts): void;
    assertImportDefaultSpecifier(opts?: Opts): void;
    assertImportNamespaceSpecifier(opts?: Opts): void;
    assertImportSpecifier(opts?: Opts): void;
    assertIndexedAccessType(opts?: Opts): void;
    assertInferredPredicate(opts?: Opts): void;
    assertInterfaceDeclaration(opts?: Opts): void;
    assertInterfaceExtends(opts?: Opts): void;
    assertInterfaceTypeAnnotation(opts?: Opts): void;
    assertInterpreterDirective(opts?: Opts): void;
    assertIntersectionTypeAnnotation(opts?: Opts): void;
    assertJSX(opts?: Opts): void;
    assertJSXAttribute(opts?: Opts): void;
    assertJSXClosingElement(opts?: Opts): void;
    assertJSXClosingFragment(opts?: Opts): void;
    assertJSXElement(opts?: Opts): void;
    assertJSXEmptyExpression(opts?: Opts): void;
    assertJSXExpressionContainer(opts?: Opts): void;
    assertJSXFragment(opts?: Opts): void;
    assertJSXIdentifier(opts?: Opts): void;
    assertJSXMemberExpression(opts?: Opts): void;
    assertJSXNamespacedName(opts?: Opts): void;
    assertJSXOpeningElement(opts?: Opts): void;
    assertJSXOpeningFragment(opts?: Opts): void;
    assertJSXSpreadAttribute(opts?: Opts): void;
    assertJSXSpreadChild(opts?: Opts): void;
    assertJSXText(opts?: Opts): void;
    assertLVal(opts?: Opts): void;
    assertLabeledStatement(opts?: Opts): void;
    assertLiteral(opts?: Opts): void;
    assertLogicalExpression(opts?: Opts): void;
    assertLoop(opts?: Opts): void;
    assertMemberExpression(opts?: Opts): void;
    assertMetaProperty(opts?: Opts): void;
    assertMethod(opts?: Opts): void;
    assertMiscellaneous(opts?: Opts): void;
    assertMixedTypeAnnotation(opts?: Opts): void;
    assertModuleDeclaration(opts?: Opts): void;
    assertModuleExpression(opts?: Opts): void;
    assertModuleSpecifier(opts?: Opts): void;
    assertNewExpression(opts?: Opts): void;
    assertNoop(opts?: Opts): void;
    assertNullLiteral(opts?: Opts): void;
    assertNullLiteralTypeAnnotation(opts?: Opts): void;
    assertNullableTypeAnnotation(opts?: Opts): void;
    assertNumberLiteral(opts?: Opts): void;
    assertNumberLiteralTypeAnnotation(opts?: Opts): void;
    assertNumberTypeAnnotation(opts?: Opts): void;
    assertNumericLiteral(opts?: Opts): void;
    assertNumericLiteralTypeAnnotation(opts?: Opts): void;
    assertObjectExpression(opts?: Opts): void;
    assertObjectMember(opts?: Opts): void;
    assertObjectMethod(opts?: Opts): void;
    assertObjectPattern(opts?: Opts): void;
    assertObjectProperty(opts?: Opts): void;
    assertObjectTypeAnnotation(opts?: Opts): void;
    assertObjectTypeCallProperty(opts?: Opts): void;
    assertObjectTypeIndexer(opts?: Opts): void;
    assertObjectTypeInternalSlot(opts?: Opts): void;
    assertObjectTypeProperty(opts?: Opts): void;
    assertObjectTypeSpreadProperty(opts?: Opts): void;
    assertOpaqueType(opts?: Opts): void;
    assertOptionalCallExpression(opts?: Opts): void;
    assertOptionalIndexedAccessType(opts?: Opts): void;
    assertOptionalMemberExpression(opts?: Opts): void;
    assertParenthesizedExpression(opts?: Opts): void;
    assertPattern(opts?: Opts): void;
    assertPatternLike(opts?: Opts): void;
    assertPipelineBareFunction(opts?: Opts): void;
    assertPipelinePrimaryTopicReference(opts?: Opts): void;
    assertPipelineTopicExpression(opts?: Opts): void;
    assertPlaceholder(opts?: Opts): void;
    assertPrivate(opts?: Opts): void;
    assertPrivateName(opts?: Opts): void;
    assertProgram(opts?: Opts): void;
    assertProperty(opts?: Opts): void;
    assertPure(opts?: Opts): void;
    assertPureish(opts?: Opts): void;
    assertQualifiedTypeIdentifier(opts?: Opts): void;
    assertRecordExpression(opts?: Opts): void;
    assertReferenced(opts?: Opts): void;
    assertReferencedIdentifier(opts?: Opts): void;
    assertReferencedMemberExpression(opts?: Opts): void;
    assertRegExpLiteral(opts?: Opts): void;
    assertRegexLiteral(opts?: Opts): void;
    assertRestElement(opts?: Opts): void;
    assertRestProperty(opts?: Opts): void;
    assertReturnStatement(opts?: Opts): void;
    assertScopable(opts?: Opts): void;
    assertScope(opts?: Opts): void;
    assertSequenceExpression(opts?: Opts): void;
    assertSpreadElement(opts?: Opts): void;
    assertSpreadProperty(opts?: Opts): void;
    assertStandardized(opts?: Opts): void;
    assertStatement(opts?: Opts): void;
    assertStaticBlock(opts?: Opts): void;
    assertStringLiteral(opts?: Opts): void;
    assertStringLiteralTypeAnnotation(opts?: Opts): void;
    assertStringTypeAnnotation(opts?: Opts): void;
    assertSuper(opts?: Opts): void;
    assertSwitchCase(opts?: Opts): void;
    assertSwitchStatement(opts?: Opts): void;
    assertSymbolTypeAnnotation(opts?: Opts): void;
    assertTSAnyKeyword(opts?: Opts): void;
    assertTSArrayType(opts?: Opts): void;
    assertTSAsExpression(opts?: Opts): void;
    assertTSBaseType(opts?: Opts): void;
    assertTSBigIntKeyword(opts?: Opts): void;
    assertTSBooleanKeyword(opts?: Opts): void;
    assertTSCallSignatureDeclaration(opts?: Opts): void;
    assertTSConditionalType(opts?: Opts): void;
    assertTSConstructSignatureDeclaration(opts?: Opts): void;
    assertTSConstructorType(opts?: Opts): void;
    assertTSDeclareFunction(opts?: Opts): void;
    assertTSDeclareMethod(opts?: Opts): void;
    assertTSEntityName(opts?: Opts): void;
    assertTSEnumDeclaration(opts?: Opts): void;
    assertTSEnumMember(opts?: Opts): void;
    assertTSExportAssignment(opts?: Opts): void;
    assertTSExpressionWithTypeArguments(opts?: Opts): void;
    assertTSExternalModuleReference(opts?: Opts): void;
    assertTSFunctionType(opts?: Opts): void;
    assertTSImportEqualsDeclaration(opts?: Opts): void;
    assertTSImportType(opts?: Opts): void;
    assertTSIndexSignature(opts?: Opts): void;
    assertTSIndexedAccessType(opts?: Opts): void;
    assertTSInferType(opts?: Opts): void;
    assertTSInstantiationExpression(opts?: Opts): void;
    assertTSInterfaceBody(opts?: Opts): void;
    assertTSInterfaceDeclaration(opts?: Opts): void;
    assertTSIntersectionType(opts?: Opts): void;
    assertTSIntrinsicKeyword(opts?: Opts): void;
    assertTSLiteralType(opts?: Opts): void;
    assertTSMappedType(opts?: Opts): void;
    assertTSMethodSignature(opts?: Opts): void;
    assertTSModuleBlock(opts?: Opts): void;
    assertTSModuleDeclaration(opts?: Opts): void;
    assertTSNamedTupleMember(opts?: Opts): void;
    assertTSNamespaceExportDeclaration(opts?: Opts): void;
    assertTSNeverKeyword(opts?: Opts): void;
    assertTSNonNullExpression(opts?: Opts): void;
    assertTSNullKeyword(opts?: Opts): void;
    assertTSNumberKeyword(opts?: Opts): void;
    assertTSObjectKeyword(opts?: Opts): void;
    assertTSOptionalType(opts?: Opts): void;
    assertTSParameterProperty(opts?: Opts): void;
    assertTSParenthesizedType(opts?: Opts): void;
    assertTSPropertySignature(opts?: Opts): void;
    assertTSQualifiedName(opts?: Opts): void;
    assertTSRestType(opts?: Opts): void;
    assertTSSatisfiesExpression(opts?: Opts): void;
    assertTSStringKeyword(opts?: Opts): void;
    assertTSSymbolKeyword(opts?: Opts): void;
    assertTSThisType(opts?: Opts): void;
    assertTSTupleType(opts?: Opts): void;
    assertTSType(opts?: Opts): void;
    assertTSTypeAliasDeclaration(opts?: Opts): void;
    assertTSTypeAnnotation(opts?: Opts): void;
    assertTSTypeAssertion(opts?: Opts): void;
    assertTSTypeElement(opts?: Opts): void;
    assertTSTypeLiteral(opts?: Opts): void;
    assertTSTypeOperator(opts?: Opts): void;
    assertTSTypeParameter(opts?: Opts): void;
    assertTSTypeParameterDeclaration(opts?: Opts): void;
    assertTSTypeParameterInstantiation(opts?: Opts): void;
    assertTSTypePredicate(opts?: Opts): void;
    assertTSTypeQuery(opts?: Opts): void;
    assertTSTypeReference(opts?: Opts): void;
    assertTSUndefinedKeyword(opts?: Opts): void;
    assertTSUnionType(opts?: Opts): void;
    assertTSUnknownKeyword(opts?: Opts): void;
    assertTSVoidKeyword(opts?: Opts): void;
    assertTaggedTemplateExpression(opts?: Opts): void;
    assertTemplateElement(opts?: Opts): void;
    assertTemplateLiteral(opts?: Opts): void;
    assertTerminatorless(opts?: Opts): void;
    assertThisExpression(opts?: Opts): void;
    assertThisTypeAnnotation(opts?: Opts): void;
    assertThrowStatement(opts?: Opts): void;
    assertTopicReference(opts?: Opts): void;
    assertTryStatement(opts?: Opts): void;
    assertTupleExpression(opts?: Opts): void;
    assertTupleTypeAnnotation(opts?: Opts): void;
    assertTypeAlias(opts?: Opts): void;
    assertTypeAnnotation(opts?: Opts): void;
    assertTypeCastExpression(opts?: Opts): void;
    assertTypeParameter(opts?: Opts): void;
    assertTypeParameterDeclaration(opts?: Opts): void;
    assertTypeParameterInstantiation(opts?: Opts): void;
    assertTypeScript(opts?: Opts): void;
    assertTypeofTypeAnnotation(opts?: Opts): void;
    assertUnaryExpression(opts?: Opts): void;
    assertUnaryLike(opts?: Opts): void;
    assertUnionTypeAnnotation(opts?: Opts): void;
    assertUpdateExpression(opts?: Opts): void;
    assertUser(opts?: Opts): void;
    assertUserWhitespacable(opts?: Opts): void;
    assertV8IntrinsicIdentifier(opts?: Opts): void;
    assertVar(opts?: Opts): void;
    assertVariableDeclaration(opts?: Opts): void;
    assertVariableDeclarator(opts?: Opts): void;
    assertVariance(opts?: Opts): void;
    assertVoidTypeAnnotation(opts?: Opts): void;
    assertWhile(opts?: Opts): void;
    assertWhileStatement(opts?: Opts): void;
    assertWithStatement(opts?: Opts): void;
    assertYieldExpression(opts?: Opts): void;
    // END GENERATED NODE PATH METHODS
  }

  declare export type VisitNodeFunction<-TNode: BabelNode, TState> = (
    path: NodePath<TNode>,
    state: TState,
  ) => void;

  declare export type VisitNodeObject<-TNode: BabelNode, TState> = Partial<{
    enter(path: NodePath<TNode>, state: TState): void,
    exit(path: NodePath<TNode>, state: TState): void,
  }>;

  declare export type VisitNode<-TNode: BabelNode, TState> =
    | VisitNodeFunction<TNode, TState>
    | VisitNodeObject<TNode, TState>;

  declare export type Visitor<TState = void> = $ReadOnly<{
    enter?: VisitNodeFunction<BabelNode, TState>,
    exit?: VisitNodeFunction<BabelNode, TState>,

    // This section is automatically generated. Don't edit by hand.
    // See the comment at the top of the file on how to update the definitions.
    // BEGIN GENERATED VISITOR METHODS
    Accessor?: VisitNode<BabelNodeAccessor, TState>,
    AnyTypeAnnotation?: VisitNode<BabelNodeAnyTypeAnnotation, TState>,
    ArgumentPlaceholder?: VisitNode<BabelNodeArgumentPlaceholder, TState>,
    ArrayExpression?: VisitNode<BabelNodeArrayExpression, TState>,
    ArrayPattern?: VisitNode<BabelNodeArrayPattern, TState>,
    ArrayTypeAnnotation?: VisitNode<BabelNodeArrayTypeAnnotation, TState>,
    ArrowFunctionExpression?: VisitNode<
      BabelNodeArrowFunctionExpression,
      TState,
    >,
    AssignmentExpression?: VisitNode<BabelNodeAssignmentExpression, TState>,
    AssignmentPattern?: VisitNode<BabelNodeAssignmentPattern, TState>,
    AwaitExpression?: VisitNode<BabelNodeAwaitExpression, TState>,
    BigIntLiteral?: VisitNode<BabelNodeBigIntLiteral, TState>,
    Binary?: VisitNode<BabelNodeBinary, TState>,
    BinaryExpression?: VisitNode<BabelNodeBinaryExpression, TState>,
    BindExpression?: VisitNode<BabelNodeBindExpression, TState>,
    BindingIdentifier?: VisitNode<BabelNode, TState>,
    Block?: VisitNode<BabelNodeBlock, TState>,
    BlockParent?: VisitNode<BabelNodeBlockParent, TState>,
    BlockScoped?: VisitNode<BabelNode, TState>,
    BlockStatement?: VisitNode<BabelNodeBlockStatement, TState>,
    BooleanLiteral?: VisitNode<BabelNodeBooleanLiteral, TState>,
    BooleanLiteralTypeAnnotation?: VisitNode<
      BabelNodeBooleanLiteralTypeAnnotation,
      TState,
    >,
    BooleanTypeAnnotation?: VisitNode<BabelNodeBooleanTypeAnnotation, TState>,
    BreakStatement?: VisitNode<BabelNodeBreakStatement, TState>,
    CallExpression?: VisitNode<BabelNodeCallExpression, TState>,
    CatchClause?: VisitNode<BabelNodeCatchClause, TState>,
    Class?: VisitNode<BabelNodeClass, TState>,
    ClassAccessorProperty?: VisitNode<BabelNodeClassAccessorProperty, TState>,
    ClassBody?: VisitNode<BabelNodeClassBody, TState>,
    ClassDeclaration?: VisitNode<BabelNodeClassDeclaration, TState>,
    ClassExpression?: VisitNode<BabelNodeClassExpression, TState>,
    ClassImplements?: VisitNode<BabelNodeClassImplements, TState>,
    ClassMethod?: VisitNode<BabelNodeClassMethod, TState>,
    ClassPrivateMethod?: VisitNode<BabelNodeClassPrivateMethod, TState>,
    ClassPrivateProperty?: VisitNode<BabelNodeClassPrivateProperty, TState>,
    ClassProperty?: VisitNode<BabelNodeClassProperty, TState>,
    CompletionStatement?: VisitNode<BabelNodeCompletionStatement, TState>,
    Conditional?: VisitNode<BabelNodeConditional, TState>,
    ConditionalExpression?: VisitNode<BabelNodeConditionalExpression, TState>,
    ContinueStatement?: VisitNode<BabelNodeContinueStatement, TState>,
    DebuggerStatement?: VisitNode<BabelNodeDebuggerStatement, TState>,
    DecimalLiteral?: VisitNode<BabelNodeDecimalLiteral, TState>,
    Declaration?: VisitNode<BabelNodeDeclaration, TState>,
    DeclareClass?: VisitNode<BabelNodeDeclareClass, TState>,
    DeclareExportAllDeclaration?: VisitNode<
      BabelNodeDeclareExportAllDeclaration,
      TState,
    >,
    DeclareExportDeclaration?: VisitNode<
      BabelNodeDeclareExportDeclaration,
      TState,
    >,
    DeclareFunction?: VisitNode<BabelNodeDeclareFunction, TState>,
    DeclareInterface?: VisitNode<BabelNodeDeclareInterface, TState>,
    DeclareModule?: VisitNode<BabelNodeDeclareModule, TState>,
    DeclareModuleExports?: VisitNode<BabelNodeDeclareModuleExports, TState>,
    DeclareOpaqueType?: VisitNode<BabelNodeDeclareOpaqueType, TState>,
    DeclareTypeAlias?: VisitNode<BabelNodeDeclareTypeAlias, TState>,
    DeclareVariable?: VisitNode<BabelNodeDeclareVariable, TState>,
    DeclaredPredicate?: VisitNode<BabelNodeDeclaredPredicate, TState>,
    Decorator?: VisitNode<BabelNodeDecorator, TState>,
    Directive?: VisitNode<BabelNodeDirective, TState>,
    DirectiveLiteral?: VisitNode<BabelNodeDirectiveLiteral, TState>,
    DoExpression?: VisitNode<BabelNodeDoExpression, TState>,
    DoWhileStatement?: VisitNode<BabelNodeDoWhileStatement, TState>,
    EmptyStatement?: VisitNode<BabelNodeEmptyStatement, TState>,
    EmptyTypeAnnotation?: VisitNode<BabelNodeEmptyTypeAnnotation, TState>,
    EnumBody?: VisitNode<BabelNodeEnumBody, TState>,
    EnumBooleanBody?: VisitNode<BabelNodeEnumBooleanBody, TState>,
    EnumBooleanMember?: VisitNode<BabelNodeEnumBooleanMember, TState>,
    EnumDeclaration?: VisitNode<BabelNodeEnumDeclaration, TState>,
    EnumDefaultedMember?: VisitNode<BabelNodeEnumDefaultedMember, TState>,
    EnumMember?: VisitNode<BabelNodeEnumMember, TState>,
    EnumNumberBody?: VisitNode<BabelNodeEnumNumberBody, TState>,
    EnumNumberMember?: VisitNode<BabelNodeEnumNumberMember, TState>,
    EnumStringBody?: VisitNode<BabelNodeEnumStringBody, TState>,
    EnumStringMember?: VisitNode<BabelNodeEnumStringMember, TState>,
    EnumSymbolBody?: VisitNode<BabelNodeEnumSymbolBody, TState>,
    ExistentialTypeParam?: VisitNode<BabelNode, TState>,
    ExistsTypeAnnotation?: VisitNode<BabelNodeExistsTypeAnnotation, TState>,
    ExportAllDeclaration?: VisitNode<BabelNodeExportAllDeclaration, TState>,
    ExportDeclaration?: VisitNode<BabelNodeExportDeclaration, TState>,
    ExportDefaultDeclaration?: VisitNode<
      BabelNodeExportDefaultDeclaration,
      TState,
    >,
    ExportDefaultSpecifier?: VisitNode<BabelNodeExportDefaultSpecifier, TState>,
    ExportNamedDeclaration?: VisitNode<BabelNodeExportNamedDeclaration, TState>,
    ExportNamespaceSpecifier?: VisitNode<
      BabelNodeExportNamespaceSpecifier,
      TState,
    >,
    ExportSpecifier?: VisitNode<BabelNodeExportSpecifier, TState>,
    Expression?: VisitNode<BabelNodeExpression, TState>,
    ExpressionStatement?: VisitNode<BabelNodeExpressionStatement, TState>,
    ExpressionWrapper?: VisitNode<BabelNodeExpressionWrapper, TState>,
    Flow?: VisitNode<BabelNodeFlow, TState>,
    FlowBaseAnnotation?: VisitNode<BabelNodeFlowBaseAnnotation, TState>,
    FlowDeclaration?: VisitNode<BabelNodeFlowDeclaration, TState>,
    FlowPredicate?: VisitNode<BabelNodeFlowPredicate, TState>,
    FlowType?: VisitNode<BabelNodeFlowType, TState>,
    For?: VisitNode<BabelNodeFor, TState>,
    ForAwaitStatement?: VisitNode<BabelNode, TState>,
    ForInStatement?: VisitNode<BabelNodeForInStatement, TState>,
    ForOfStatement?: VisitNode<BabelNodeForOfStatement, TState>,
    ForStatement?: VisitNode<BabelNodeForStatement, TState>,
    ForXStatement?: VisitNode<BabelNodeForXStatement, TState>,
    Function?: VisitNode<BabelNodeFunction, TState>,
    FunctionDeclaration?: VisitNode<BabelNodeFunctionDeclaration, TState>,
    FunctionExpression?: VisitNode<BabelNodeFunctionExpression, TState>,
    FunctionParent?: VisitNode<BabelNodeFunctionParent, TState>,
    FunctionTypeAnnotation?: VisitNode<BabelNodeFunctionTypeAnnotation, TState>,
    FunctionTypeParam?: VisitNode<BabelNodeFunctionTypeParam, TState>,
    Generated?: VisitNode<BabelNode, TState>,
    GenericTypeAnnotation?: VisitNode<BabelNodeGenericTypeAnnotation, TState>,
    Identifier?: VisitNode<BabelNodeIdentifier, TState>,
    IfStatement?: VisitNode<BabelNodeIfStatement, TState>,
    Immutable?: VisitNode<BabelNodeImmutable, TState>,
    Import?: VisitNode<BabelNodeImport, TState>,
    ImportAttribute?: VisitNode<BabelNodeImportAttribute, TState>,
    ImportDeclaration?: VisitNode<BabelNodeImportDeclaration, TState>,
    ImportDefaultSpecifier?: VisitNode<BabelNodeImportDefaultSpecifier, TState>,
    ImportNamespaceSpecifier?: VisitNode<
      BabelNodeImportNamespaceSpecifier,
      TState,
    >,
    ImportSpecifier?: VisitNode<BabelNodeImportSpecifier, TState>,
    IndexedAccessType?: VisitNode<BabelNodeIndexedAccessType, TState>,
    InferredPredicate?: VisitNode<BabelNodeInferredPredicate, TState>,
    InterfaceDeclaration?: VisitNode<BabelNodeInterfaceDeclaration, TState>,
    InterfaceExtends?: VisitNode<BabelNodeInterfaceExtends, TState>,
    InterfaceTypeAnnotation?: VisitNode<
      BabelNodeInterfaceTypeAnnotation,
      TState,
    >,
    InterpreterDirective?: VisitNode<BabelNodeInterpreterDirective, TState>,
    IntersectionTypeAnnotation?: VisitNode<
      BabelNodeIntersectionTypeAnnotation,
      TState,
    >,
    JSX?: VisitNode<BabelNodeJSX, TState>,
    JSXAttribute?: VisitNode<BabelNodeJSXAttribute, TState>,
    JSXClosingElement?: VisitNode<BabelNodeJSXClosingElement, TState>,
    JSXClosingFragment?: VisitNode<BabelNodeJSXClosingFragment, TState>,
    JSXElement?: VisitNode<BabelNodeJSXElement, TState>,
    JSXEmptyExpression?: VisitNode<BabelNodeJSXEmptyExpression, TState>,
    JSXExpressionContainer?: VisitNode<BabelNodeJSXExpressionContainer, TState>,
    JSXFragment?: VisitNode<BabelNodeJSXFragment, TState>,
    JSXIdentifier?: VisitNode<BabelNodeJSXIdentifier, TState>,
    JSXMemberExpression?: VisitNode<BabelNodeJSXMemberExpression, TState>,
    JSXNamespacedName?: VisitNode<BabelNodeJSXNamespacedName, TState>,
    JSXOpeningElement?: VisitNode<BabelNodeJSXOpeningElement, TState>,
    JSXOpeningFragment?: VisitNode<BabelNodeJSXOpeningFragment, TState>,
    JSXSpreadAttribute?: VisitNode<BabelNodeJSXSpreadAttribute, TState>,
    JSXSpreadChild?: VisitNode<BabelNodeJSXSpreadChild, TState>,
    JSXText?: VisitNode<BabelNodeJSXText, TState>,
    LVal?: VisitNode<BabelNodeLVal, TState>,
    LabeledStatement?: VisitNode<BabelNodeLabeledStatement, TState>,
    Literal?: VisitNode<BabelNodeLiteral, TState>,
    LogicalExpression?: VisitNode<BabelNodeLogicalExpression, TState>,
    Loop?: VisitNode<BabelNodeLoop, TState>,
    MemberExpression?: VisitNode<BabelNodeMemberExpression, TState>,
    MetaProperty?: VisitNode<BabelNodeMetaProperty, TState>,
    Method?: VisitNode<BabelNodeMethod, TState>,
    Miscellaneous?: VisitNode<BabelNodeMiscellaneous, TState>,
    MixedTypeAnnotation?: VisitNode<BabelNodeMixedTypeAnnotation, TState>,
    ModuleDeclaration?: VisitNode<BabelNodeModuleDeclaration, TState>,
    ModuleExpression?: VisitNode<BabelNodeModuleExpression, TState>,
    ModuleSpecifier?: VisitNode<BabelNodeModuleSpecifier, TState>,
    NewExpression?: VisitNode<BabelNodeNewExpression, TState>,
    Noop?: VisitNode<BabelNodeNoop, TState>,
    NullLiteral?: VisitNode<BabelNodeNullLiteral, TState>,
    NullLiteralTypeAnnotation?: VisitNode<
      BabelNodeNullLiteralTypeAnnotation,
      TState,
    >,
    NullableTypeAnnotation?: VisitNode<BabelNodeNullableTypeAnnotation, TState>,
    NumberLiteral?: VisitNode<BabelNode, TState>,
    NumberLiteralTypeAnnotation?: VisitNode<
      BabelNodeNumberLiteralTypeAnnotation,
      TState,
    >,
    NumberTypeAnnotation?: VisitNode<BabelNodeNumberTypeAnnotation, TState>,
    NumericLiteral?: VisitNode<BabelNodeNumericLiteral, TState>,
    NumericLiteralTypeAnnotation?: VisitNode<BabelNode, TState>,
    ObjectExpression?: VisitNode<BabelNodeObjectExpression, TState>,
    ObjectMember?: VisitNode<BabelNodeObjectMember, TState>,
    ObjectMethod?: VisitNode<BabelNodeObjectMethod, TState>,
    ObjectPattern?: VisitNode<BabelNodeObjectPattern, TState>,
    ObjectProperty?: VisitNode<BabelNodeObjectProperty, TState>,
    ObjectTypeAnnotation?: VisitNode<BabelNodeObjectTypeAnnotation, TState>,
    ObjectTypeCallProperty?: VisitNode<BabelNodeObjectTypeCallProperty, TState>,
    ObjectTypeIndexer?: VisitNode<BabelNodeObjectTypeIndexer, TState>,
    ObjectTypeInternalSlot?: VisitNode<BabelNodeObjectTypeInternalSlot, TState>,
    ObjectTypeProperty?: VisitNode<BabelNodeObjectTypeProperty, TState>,
    ObjectTypeSpreadProperty?: VisitNode<
      BabelNodeObjectTypeSpreadProperty,
      TState,
    >,
    OpaqueType?: VisitNode<BabelNodeOpaqueType, TState>,
    OptionalCallExpression?: VisitNode<BabelNodeOptionalCallExpression, TState>,
    OptionalIndexedAccessType?: VisitNode<
      BabelNodeOptionalIndexedAccessType,
      TState,
    >,
    OptionalMemberExpression?: VisitNode<
      BabelNodeOptionalMemberExpression,
      TState,
    >,
    ParenthesizedExpression?: VisitNode<
      BabelNodeParenthesizedExpression,
      TState,
    >,
    Pattern?: VisitNode<BabelNodePattern, TState>,
    PatternLike?: VisitNode<BabelNodePatternLike, TState>,
    PipelineBareFunction?: VisitNode<BabelNodePipelineBareFunction, TState>,
    PipelinePrimaryTopicReference?: VisitNode<
      BabelNodePipelinePrimaryTopicReference,
      TState,
    >,
    PipelineTopicExpression?: VisitNode<
      BabelNodePipelineTopicExpression,
      TState,
    >,
    Placeholder?: VisitNode<BabelNodePlaceholder, TState>,
    Private?: VisitNode<BabelNodePrivate, TState>,
    PrivateName?: VisitNode<BabelNodePrivateName, TState>,
    Program?: VisitNode<BabelNodeProgram, TState>,
    Property?: VisitNode<BabelNodeProperty, TState>,
    Pure?: VisitNode<BabelNode, TState>,
    Pureish?: VisitNode<BabelNodePureish, TState>,
    QualifiedTypeIdentifier?: VisitNode<
      BabelNodeQualifiedTypeIdentifier,
      TState,
    >,
    RecordExpression?: VisitNode<BabelNodeRecordExpression, TState>,
    Referenced?: VisitNode<BabelNode, TState>,
    ReferencedIdentifier?: VisitNode<BabelNode, TState>,
    ReferencedMemberExpression?: VisitNode<BabelNode, TState>,
    RegExpLiteral?: VisitNode<BabelNodeRegExpLiteral, TState>,
    RegexLiteral?: VisitNode<BabelNode, TState>,
    RestElement?: VisitNode<BabelNodeRestElement, TState>,
    RestProperty?: VisitNode<BabelNode, TState>,
    ReturnStatement?: VisitNode<BabelNodeReturnStatement, TState>,
    Scopable?: VisitNode<BabelNodeScopable, TState>,
    Scope?: VisitNode<BabelNode, TState>,
    SequenceExpression?: VisitNode<BabelNodeSequenceExpression, TState>,
    SpreadElement?: VisitNode<BabelNodeSpreadElement, TState>,
    SpreadProperty?: VisitNode<BabelNode, TState>,
    Standardized?: VisitNode<BabelNodeStandardized, TState>,
    Statement?: VisitNode<BabelNodeStatement, TState>,
    StaticBlock?: VisitNode<BabelNodeStaticBlock, TState>,
    StringLiteral?: VisitNode<BabelNodeStringLiteral, TState>,
    StringLiteralTypeAnnotation?: VisitNode<
      BabelNodeStringLiteralTypeAnnotation,
      TState,
    >,
    StringTypeAnnotation?: VisitNode<BabelNodeStringTypeAnnotation, TState>,
    Super?: VisitNode<BabelNodeSuper, TState>,
    SwitchCase?: VisitNode<BabelNodeSwitchCase, TState>,
    SwitchStatement?: VisitNode<BabelNodeSwitchStatement, TState>,
    SymbolTypeAnnotation?: VisitNode<BabelNodeSymbolTypeAnnotation, TState>,
    TSAnyKeyword?: VisitNode<BabelNodeTSAnyKeyword, TState>,
    TSArrayType?: VisitNode<BabelNodeTSArrayType, TState>,
    TSAsExpression?: VisitNode<BabelNodeTSAsExpression, TState>,
    TSBaseType?: VisitNode<BabelNodeTSBaseType, TState>,
    TSBigIntKeyword?: VisitNode<BabelNodeTSBigIntKeyword, TState>,
    TSBooleanKeyword?: VisitNode<BabelNodeTSBooleanKeyword, TState>,
    TSCallSignatureDeclaration?: VisitNode<
      BabelNodeTSCallSignatureDeclaration,
      TState,
    >,
    TSConditionalType?: VisitNode<BabelNodeTSConditionalType, TState>,
    TSConstructSignatureDeclaration?: VisitNode<
      BabelNodeTSConstructSignatureDeclaration,
      TState,
    >,
    TSConstructorType?: VisitNode<BabelNodeTSConstructorType, TState>,
    TSDeclareFunction?: VisitNode<BabelNodeTSDeclareFunction, TState>,
    TSDeclareMethod?: VisitNode<BabelNodeTSDeclareMethod, TState>,
    TSEntityName?: VisitNode<BabelNodeTSEntityName, TState>,
    TSEnumDeclaration?: VisitNode<BabelNodeTSEnumDeclaration, TState>,
    TSEnumMember?: VisitNode<BabelNodeTSEnumMember, TState>,
    TSExportAssignment?: VisitNode<BabelNodeTSExportAssignment, TState>,
    TSExpressionWithTypeArguments?: VisitNode<
      BabelNodeTSExpressionWithTypeArguments,
      TState,
    >,
    TSExternalModuleReference?: VisitNode<
      BabelNodeTSExternalModuleReference,
      TState,
    >,
    TSFunctionType?: VisitNode<BabelNodeTSFunctionType, TState>,
    TSImportEqualsDeclaration?: VisitNode<
      BabelNodeTSImportEqualsDeclaration,
      TState,
    >,
    TSImportType?: VisitNode<BabelNodeTSImportType, TState>,
    TSIndexSignature?: VisitNode<BabelNodeTSIndexSignature, TState>,
    TSIndexedAccessType?: VisitNode<BabelNodeTSIndexedAccessType, TState>,
    TSInferType?: VisitNode<BabelNodeTSInferType, TState>,
    TSInstantiationExpression?: VisitNode<
      BabelNodeTSInstantiationExpression,
      TState,
    >,
    TSInterfaceBody?: VisitNode<BabelNodeTSInterfaceBody, TState>,
    TSInterfaceDeclaration?: VisitNode<BabelNodeTSInterfaceDeclaration, TState>,
    TSIntersectionType?: VisitNode<BabelNodeTSIntersectionType, TState>,
    TSIntrinsicKeyword?: VisitNode<BabelNodeTSIntrinsicKeyword, TState>,
    TSLiteralType?: VisitNode<BabelNodeTSLiteralType, TState>,
    TSMappedType?: VisitNode<BabelNodeTSMappedType, TState>,
    TSMethodSignature?: VisitNode<BabelNodeTSMethodSignature, TState>,
    TSModuleBlock?: VisitNode<BabelNodeTSModuleBlock, TState>,
    TSModuleDeclaration?: VisitNode<BabelNodeTSModuleDeclaration, TState>,
    TSNamedTupleMember?: VisitNode<BabelNodeTSNamedTupleMember, TState>,
    TSNamespaceExportDeclaration?: VisitNode<
      BabelNodeTSNamespaceExportDeclaration,
      TState,
    >,
    TSNeverKeyword?: VisitNode<BabelNodeTSNeverKeyword, TState>,
    TSNonNullExpression?: VisitNode<BabelNodeTSNonNullExpression, TState>,
    TSNullKeyword?: VisitNode<BabelNodeTSNullKeyword, TState>,
    TSNumberKeyword?: VisitNode<BabelNodeTSNumberKeyword, TState>,
    TSObjectKeyword?: VisitNode<BabelNodeTSObjectKeyword, TState>,
    TSOptionalType?: VisitNode<BabelNodeTSOptionalType, TState>,
    TSParameterProperty?: VisitNode<BabelNodeTSParameterProperty, TState>,
    TSParenthesizedType?: VisitNode<BabelNodeTSParenthesizedType, TState>,
    TSPropertySignature?: VisitNode<BabelNodeTSPropertySignature, TState>,
    TSQualifiedName?: VisitNode<BabelNodeTSQualifiedName, TState>,
    TSRestType?: VisitNode<BabelNodeTSRestType, TState>,
    TSSatisfiesExpression?: VisitNode<BabelNodeTSSatisfiesExpression, TState>,
    TSStringKeyword?: VisitNode<BabelNodeTSStringKeyword, TState>,
    TSSymbolKeyword?: VisitNode<BabelNodeTSSymbolKeyword, TState>,
    TSThisType?: VisitNode<BabelNodeTSThisType, TState>,
    TSTupleType?: VisitNode<BabelNodeTSTupleType, TState>,
    TSType?: VisitNode<BabelNodeTSType, TState>,
    TSTypeAliasDeclaration?: VisitNode<BabelNodeTSTypeAliasDeclaration, TState>,
    TSTypeAnnotation?: VisitNode<BabelNodeTSTypeAnnotation, TState>,
    TSTypeAssertion?: VisitNode<BabelNodeTSTypeAssertion, TState>,
    TSTypeElement?: VisitNode<BabelNodeTSTypeElement, TState>,
    TSTypeLiteral?: VisitNode<BabelNodeTSTypeLiteral, TState>,
    TSTypeOperator?: VisitNode<BabelNodeTSTypeOperator, TState>,
    TSTypeParameter?: VisitNode<BabelNodeTSTypeParameter, TState>,
    TSTypeParameterDeclaration?: VisitNode<
      BabelNodeTSTypeParameterDeclaration,
      TState,
    >,
    TSTypeParameterInstantiation?: VisitNode<
      BabelNodeTSTypeParameterInstantiation,
      TState,
    >,
    TSTypePredicate?: VisitNode<BabelNodeTSTypePredicate, TState>,
    TSTypeQuery?: VisitNode<BabelNodeTSTypeQuery, TState>,
    TSTypeReference?: VisitNode<BabelNodeTSTypeReference, TState>,
    TSUndefinedKeyword?: VisitNode<BabelNodeTSUndefinedKeyword, TState>,
    TSUnionType?: VisitNode<BabelNodeTSUnionType, TState>,
    TSUnknownKeyword?: VisitNode<BabelNodeTSUnknownKeyword, TState>,
    TSVoidKeyword?: VisitNode<BabelNodeTSVoidKeyword, TState>,
    TaggedTemplateExpression?: VisitNode<
      BabelNodeTaggedTemplateExpression,
      TState,
    >,
    TemplateElement?: VisitNode<BabelNodeTemplateElement, TState>,
    TemplateLiteral?: VisitNode<BabelNodeTemplateLiteral, TState>,
    Terminatorless?: VisitNode<BabelNodeTerminatorless, TState>,
    ThisExpression?: VisitNode<BabelNodeThisExpression, TState>,
    ThisTypeAnnotation?: VisitNode<BabelNodeThisTypeAnnotation, TState>,
    ThrowStatement?: VisitNode<BabelNodeThrowStatement, TState>,
    TopicReference?: VisitNode<BabelNodeTopicReference, TState>,
    TryStatement?: VisitNode<BabelNodeTryStatement, TState>,
    TupleExpression?: VisitNode<BabelNodeTupleExpression, TState>,
    TupleTypeAnnotation?: VisitNode<BabelNodeTupleTypeAnnotation, TState>,
    TypeAlias?: VisitNode<BabelNodeTypeAlias, TState>,
    TypeAnnotation?: VisitNode<BabelNodeTypeAnnotation, TState>,
    TypeCastExpression?: VisitNode<BabelNodeTypeCastExpression, TState>,
    TypeParameter?: VisitNode<BabelNodeTypeParameter, TState>,
    TypeParameterDeclaration?: VisitNode<
      BabelNodeTypeParameterDeclaration,
      TState,
    >,
    TypeParameterInstantiation?: VisitNode<
      BabelNodeTypeParameterInstantiation,
      TState,
    >,
    TypeScript?: VisitNode<BabelNodeTypeScript, TState>,
    TypeofTypeAnnotation?: VisitNode<BabelNodeTypeofTypeAnnotation, TState>,
    UnaryExpression?: VisitNode<BabelNodeUnaryExpression, TState>,
    UnaryLike?: VisitNode<BabelNodeUnaryLike, TState>,
    UnionTypeAnnotation?: VisitNode<BabelNodeUnionTypeAnnotation, TState>,
    UpdateExpression?: VisitNode<BabelNodeUpdateExpression, TState>,
    User?: VisitNode<BabelNode, TState>,
    UserWhitespacable?: VisitNode<BabelNodeUserWhitespacable, TState>,
    V8IntrinsicIdentifier?: VisitNode<BabelNodeV8IntrinsicIdentifier, TState>,
    Var?: VisitNode<BabelNode, TState>,
    VariableDeclaration?: VisitNode<BabelNodeVariableDeclaration, TState>,
    VariableDeclarator?: VisitNode<BabelNodeVariableDeclarator, TState>,
    Variance?: VisitNode<BabelNodeVariance, TState>,
    VoidTypeAnnotation?: VisitNode<BabelNodeVoidTypeAnnotation, TState>,
    While?: VisitNode<BabelNodeWhile, TState>,
    WhileStatement?: VisitNode<BabelNodeWhileStatement, TState>,
    WithStatement?: VisitNode<BabelNodeWithStatement, TState>,
    YieldExpression?: VisitNode<BabelNodeYieldExpression, TState>,
    // END GENERATED VISITOR METHODS
  }>;

  declare type Visitors = {
    explode<TState>(visitor: Visitor<TState>): Visitor<TState>,
    verify<TState>(visitor: Visitor<TState>): void,
    merge(
      visitors: Array<$ReadOnly<Visitor<any>>>,
      states: Array<any>,
      wrapper?: ?Function,
    ): Array<Visitor<any>>,
  };

  declare export var visitors: Visitors;

  declare export type Cache = {
    path: $ReadOnlyWeakMap<BabelNode, mixed>,
    scope: $ReadOnlyWeakMap<BabelNode, mixed>,
    clear(): void,
    clearPath(): void,
    clearScope(): void,
  };

  declare export type Traverse = {
    <TState>(
      parent?: BabelNode | Array<BabelNode>,
      opts?: $ReadOnly<TraverseOptions<TState>>,
      scope?: ?Scope,
      state: TState,
      parentPath?: ?NodePath<BabelNode>,
    ): void,

    +cache: Cache,
    +visitors: Visitors,
    +verify: Visitors['verify'],
    +explode: Visitors['explode'],

    cheap<TOptions>(
      node: BabelNode,
      enter: (node: BabelNode, opts: TOptions) => void,
    ): void,

    node<TState>(
      node: BabelNode,
      opts: $ReadOnly<TraverseOptions<TState>>,
      scope: Scope,
      state: TState,
      parentPath: NodePath<>,
      skipKeys?: {[key: string]: boolean},
    ): void,

    clearNode(node: BabelNode, opts?: {...}): void,
    removeProperties(tree: BabelNode, opts?: {...}): BabelNode,
    hasType(
      tree: BabelNode,
      type: BabelNode['type'],
      blacklistTypes: Array<BabelNode['type']>,
    ): boolean,
  };

  declare export default Traverse;
}