// Type definitions for @babel/traverse 7.18
// Project: https://github.com/babel/babel/tree/main/packages/babel-traverse, https://babeljs.io
// Definitions by: Troy Gerwien <https://github.com/yortus>
//                 Marvin Hagemeister <https://github.com/marvinhagemeister>
//                 Ryan Petrich <https://github.com/rpetrich>
//                 Melvin Groenhoff <https://github.com/mgroenhoff>
//                 Dean L. <https://github.com/dlgrit>
//                 Ifiok Jr. <https://github.com/ifiokjr>
//                 ExE Boss <https://github.com/ExE-Boss>
//                 Daniel Tschinder <https://github.com/danez>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped

import * as t from '@babel/types';
export import Node = t.Node;

declare const traverse: {
    <S>(
        parent: Node | Node[] | null | undefined,
        opts: TraverseOptions<S>,
        scope: Scope | undefined,
        state: S,
        parentPath?: NodePath,
    ): void;
    (
        parent: Node | Node[] | null | undefined,
        opts?: TraverseOptions,
        scope?: Scope,
        state?: any,
        parentPath?: NodePath,
    ): void;

    visitors: typeof visitors;
    verify: typeof visitors.verify;
    explode: typeof visitors.explode;
};

export namespace visitors {
    /**
     * `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
     */
    function explode<S = {}>(
        visitor: Visitor<S>,
    ): {
        [Type in Node['type']]?: VisitNodeObject<S, Extract<Node, { type: Type }>>;
    };
    function verify(visitor: Visitor): void;
    function merge<S = {}>(visitors: Array<Visitor<S>>, states?: S[]): Visitor<unknown>;
}

export default traverse;

export interface TraverseOptions<S = Node> extends Visitor<S> {
    scope?: Scope | undefined;
    noScope?: boolean | undefined;
}

export type ArrayKeys<T> = keyof { [P in keyof T as T[P] extends any[] ? P : never]: P };

export class Scope {
    constructor(path: NodePath, parentScope?: Scope);
    path: NodePath;
    block: Node;
    parentBlock: Node;
    parent: Scope;
    hub: HubInterface;
    bindings: { [name: string]: Binding };

    /** Traverse node with current scope and path. */
    traverse<S>(node: Node | Node[], opts: TraverseOptions<S>, state: S): void;
    traverse(node: Node | 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 a unique identifier based on a node. */
    generateUidIdentifierBasedOnNode(parent: Node, defaultName?: string): t.Identifier;

    /**
     * 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: Node): boolean;

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

    checkBlockScopedCollisions(local: Binding, kind: BindingKind, name: string, id: object): void;

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

    dump(): void;

    toArray(node: Node, i?: number): Node;

    registerDeclaration(path: NodePath): void;

    buildUndefinedNode(): Node;

    registerConstantViolation(path: NodePath): void;

    registerBinding(kind: string, path: NodePath, bindingPath?: NodePath): void;

    addGlobal(node: Node): void;

    hasUid(name: string): boolean;

    hasGlobal(name: string): boolean;

    hasReference(name: string): boolean;

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

    setData(key: string, val: any): any;

    getData(key: string): any;

    removeData(key: string): void;

    crawl(): void;

    push(opts: {
        id: t.LVal;
        init?: t.Expression | undefined;
        unique?: boolean | undefined;
        kind?: 'var' | 'let' | 'const' | undefined;
    }): void;

    getProgramParent(): Scope;

    getFunctionParent(): Scope | null;

    getBlockParent(): Scope;

    /** Walks the scope tree and gathers **all** bindings. */
    getAllBindings(...kinds: string[]): object;

    bindingIdentifierEquals(name: string, node: 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, 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;
}

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

export class Binding {
    constructor(opts: { identifier: t.Identifier; scope: Scope; path: NodePath; kind: BindingKind });
    identifier: t.Identifier;
    scope: Scope;
    path: NodePath;
    kind: BindingKind;
    referenced: boolean;
    references: number;
    referencePaths: NodePath[];
    constant: boolean;
    constantViolations: NodePath[];
    hasDeoptedValue?: boolean;
    hasValue?: boolean;
    value?: any;

    deopValue(): void;
    setValue(value: any): void;
    clearValue(): void;

    reassign(path: NodePath): void;
    reference(path: NodePath): void;
    dereference(): void;
}

export type Visitor<S = {}> = VisitNodeObject<S, Node> & {
    [Type in Node['type']]?: VisitNode<S, Extract<Node, { type: Type }>>;
} & {
    [K in keyof t.Aliases]?: VisitNode<S, t.Aliases[K]>;
};

export type VisitNode<S, P extends Node> = VisitNodeFunction<S, P> | VisitNodeObject<S, P>;

export type VisitNodeFunction<S, P extends Node> = (this: S, path: NodePath<P>, state: S) => void;

type NodeType = Node['type'] | keyof t.Aliases;

export interface VisitNodeObject<S, P extends Node> {
    enter?: VisitNodeFunction<S, P> | undefined;
    exit?: VisitNodeFunction<S, P> | undefined;
    denylist?: NodeType[] | undefined;
    /**
     * @deprecated will be removed in Babel 8
     */
    blacklist?: NodeType[] | undefined;
}

export type NodePaths<T extends Node | readonly Node[]> = T extends readonly Node[]
    ? { -readonly [K in keyof T]: NodePath<Extract<T[K], Node>> }
    : T extends Node
    ? [NodePath<T>]
    : never;

export class NodePath<T = Node> {
    constructor(hub: Hub, parent: Node);
    parent: Node;
    hub: Hub;
    contexts: TraversalContext[];
    data: object;
    shouldSkip: boolean;
    shouldStop: boolean;
    removed: boolean;
    state: any;
    opts: object;
    skipKeys: object;
    parentPath: T extends t.Program ? null : NodePath;
    context: TraversalContext;
    container: object | object[];
    listKey: string;
    inList: boolean;
    parentKey: string;
    key: string | number;
    node: T;
    scope: Scope;
    type: T extends null | undefined ? undefined : T extends Node ? T['type'] : string | undefined;
    typeAnnotation: object;

    getScope(scope: Scope): Scope;

    setData(key: string, val: any): any;

    getData(key: string, def?: any): any;

    hasNode(): this is NodePath<NonNullable<this['node']>>;

    buildCodeFrameError<TError extends Error>(msg: string, Error?: new (msg: string) => TError): TError;

    traverse<T>(visitor: Visitor<T>, state: T): void;
    traverse(visitor: Visitor): void;

    set(key: string, node: Node): void;

    getPathLocation(): string;

    // Example: https://github.com/babel/babel/blob/63204ae51e020d84a5b246312f5eeb4d981ab952/packages/babel-traverse/src/path/modification.js#L83
    debug(buildMessage: () => string): void;

    static get<C extends Node, K extends keyof C>(opts: {
        hub: HubInterface;
        parentPath: NodePath | null;
        parent: Node;
        container: C;
        listKey?: string | undefined;
        key: K;
    }): NodePath<C[K]>;

    //#region ------------------------- 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<t.Function> | null;

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

    /**
     * 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: NodePath[]): NodePath;

    /** Get the earliest path in the tree where the provided `paths` intersect. */
    getDeepestCommonAncestorFrom(
        paths: NodePath[],
        filter?: (deepest: Node, 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.
     */
    getAncestry(): [this, ...NodePath[]];

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

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

    inType(...candidateTypes: string[]): boolean;
    //#endregion

    //#region ------------------------- inference -------------------------
    /** Infer the type of the current `NodePath`. */
    getTypeAnnotation(): t.FlowType;

    isBaseType(baseName: string, soft?: boolean): boolean;

    couldBeBaseType(name: string): boolean;

    baseTypeStrictlyMatches(right: NodePath): boolean;

    isGenericType(genericName: string): boolean;
    //#endregion

    //#region ------------------------- 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<Nodes extends readonly Node[]>(nodes: Nodes): NodePaths<Nodes>;

    /**
     * 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: any): [NodePath];

    /** Replace the current node with another. */
    replaceWith<T extends Node>(replacement: T | NodePath<T>): [NodePath<T>];

    /**
     * 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.
     */
    replaceExpressionWithStatements<Nodes extends readonly Node[]>(nodes: Nodes): NodePaths<Nodes>;

    replaceInline<Nodes extends Node | readonly Node[]>(nodes: Nodes): NodePaths<Nodes>;
    //#endregion

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

    /**
     * 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: boolean; value: any };
    //#endregion

    //#region ------------------------- 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: string): boolean;

    isStatic(): boolean;

    /** Alias of `has`. */
    is(key: string): boolean;

    /** Opposite of `has`. */
    isnt(key: string): boolean;

    /** Check whether the path node `key` strict equals `value`. */
    equals(key: string, 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: 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.
     */
    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: Node): 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;

    /** Check if the current path will maybe execute before another path */
    willIMaybeExecuteBefore(path: NodePath): boolean;
    //#endregion

    //#region ------------------------- context -------------------------
    call(key: string): boolean;

    isBlacklisted(): boolean;

    visit(): boolean;

    skip(): void;

    skipKey(key: string): void;

    stop(): void;

    setScope(): void;

    setContext(context?: TraversalContext): this;

    popContext(): void;

    pushContext(context: TraversalContext): void;
    //#endregion

    //#region ------------------------- removal -------------------------
    remove(): void;
    //#endregion

    //#region ------------------------- modification -------------------------
    /** Insert the provided nodes before the current one. */
    insertBefore<Nodes extends Node | readonly Node[]>(nodes: Nodes): NodePaths<Nodes>;

    /**
     * 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 extends Node | readonly Node[]>(nodes: Nodes): NodePaths<Nodes>;

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

    /**
     * Insert child nodes at the start of the current node.
     * @param listKey - The key at which the child nodes are stored (usually body).
     * @param nodes - the nodes to insert.
     */
    unshiftContainer<Nodes extends Node | readonly Node[]>(listKey: ArrayKeys<T>, nodes: Nodes): NodePaths<Nodes>;

    /**
     * Insert child nodes at the end of the current node.
     * @param listKey - The key at which the child nodes are stored (usually body).
     * @param nodes - the nodes to insert.
     */
    pushContainer<Nodes extends Node | readonly Node[]>(listKey: ArrayKeys<T>, nodes: Nodes): NodePaths<Nodes>;

    /** Hoist the current node to the highest scope possible and return a UID referencing it. */
    hoist(scope: Scope): void;
    //#endregion

    //#region ------------------------- family -------------------------
    getOpposite(): NodePath;

    getCompletionRecords(): NodePath[];

    getSibling(key: string | number): NodePath;
    getPrevSibling(): NodePath;
    getNextSibling(): NodePath;
    getAllPrevSiblings(): NodePath[];
    getAllNextSiblings(): NodePath[];

    get<K extends keyof T>(
        key: K,
        context?: boolean | TraversalContext,
    ): T[K] extends Array<Node | null | undefined>
        ? Array<NodePath<T[K][number]>>
        : T[K] extends Array<Node | null | undefined> | null | undefined
        ? Array<NodePath<NonNullable<T[K]>[number]>> | NodePath<null | undefined>
        : T[K] extends Node | null | undefined
        ? NodePath<T[K]>
        : never;
    get(key: string, context?: boolean | TraversalContext): NodePath | NodePath[];

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

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

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

    getOuterBindingIdentifierPaths(duplicates: true): Record<string, Array<NodePath<t.Identifier>>>;
    getOuterBindingIdentifierPaths(duplicates?: false): Record<string, NodePath<t.Identifier>>;
    getOuterBindingIdentifierPaths(
        duplicates?: boolean,
        outerOnly?: boolean,
    ): Record<string, NodePath<t.Identifier> | Array<NodePath<t.Identifier>>>;
    //#endregion

    //#region ------------------------- comments -------------------------
    /** Share comments amongst siblings. */
    shareCommentsWithSiblings(): void;

    addComment(type: string, content: string, line?: boolean): void;

    /** Give node `comments` of the specified `type`. */
    addComments(type: string, comments: any[]): void;
    //#endregion

    //#region ------------------------- isXXX -------------------------
    isAnyTypeAnnotation(props?: object | null): this is NodePath<t.AnyTypeAnnotation>;
    isArrayExpression(props?: object | null): this is NodePath<t.ArrayExpression>;
    isArrayPattern(props?: object | null): this is NodePath<t.ArrayPattern>;
    isArrayTypeAnnotation(props?: object | null): this is NodePath<t.ArrayTypeAnnotation>;
    isArrowFunctionExpression(props?: object | null): this is NodePath<t.ArrowFunctionExpression>;
    isAssignmentExpression(props?: object | null): this is NodePath<t.AssignmentExpression>;
    isAssignmentPattern(props?: object | null): this is NodePath<t.AssignmentPattern>;
    isAwaitExpression(props?: object | null): this is NodePath<t.AwaitExpression>;
    isBigIntLiteral(props?: object | null): this is NodePath<t.BigIntLiteral>;
    isBinary(props?: object | null): this is NodePath<t.Binary>;
    isBinaryExpression(props?: object | null): this is NodePath<t.BinaryExpression>;
    isBindExpression(props?: object | null): this is NodePath<t.BindExpression>;
    isBlock(props?: object | null): this is NodePath<t.Block>;
    isBlockParent(props?: object | null): this is NodePath<t.BlockParent>;
    isBlockStatement(props?: object | null): this is NodePath<t.BlockStatement>;
    isBooleanLiteral(props?: object | null): this is NodePath<t.BooleanLiteral>;
    isBooleanLiteralTypeAnnotation(props?: object | null): this is NodePath<t.BooleanLiteralTypeAnnotation>;
    isBooleanTypeAnnotation(props?: object | null): this is NodePath<t.BooleanTypeAnnotation>;
    isBreakStatement(props?: object | null): this is NodePath<t.BreakStatement>;
    isCallExpression(props?: object | null): this is NodePath<t.CallExpression>;
    isCatchClause(props?: object | null): this is NodePath<t.CatchClause>;
    isClass(props?: object | null): this is NodePath<t.Class>;
    isClassBody(props?: object | null): this is NodePath<t.ClassBody>;
    isClassDeclaration(props?: object | null): this is NodePath<t.ClassDeclaration>;
    isClassExpression(props?: object | null): this is NodePath<t.ClassExpression>;
    isClassImplements(props?: object | null): this is NodePath<t.ClassImplements>;
    isClassMethod(props?: object | null): this is NodePath<t.ClassMethod>;
    isClassPrivateMethod(props?: object | null): this is NodePath<t.ClassPrivateMethod>;
    isClassPrivateProperty(props?: object | null): this is NodePath<t.ClassPrivateProperty>;
    isClassProperty(props?: object | null): this is NodePath<t.ClassProperty>;
    isCompletionStatement(props?: object | null): this is NodePath<t.CompletionStatement>;
    isConditional(props?: object | null): this is NodePath<t.Conditional>;
    isConditionalExpression(props?: object | null): this is NodePath<t.ConditionalExpression>;
    isContinueStatement(props?: object | null): this is NodePath<t.ContinueStatement>;
    isDebuggerStatement(props?: object | null): this is NodePath<t.DebuggerStatement>;
    isDeclaration(props?: object | null): this is NodePath<t.Declaration>;
    isDeclareClass(props?: object | null): this is NodePath<t.DeclareClass>;
    isDeclareExportAllDeclaration(props?: object | null): this is NodePath<t.DeclareExportAllDeclaration>;
    isDeclareExportDeclaration(props?: object | null): this is NodePath<t.DeclareExportDeclaration>;
    isDeclareFunction(props?: object | null): this is NodePath<t.DeclareFunction>;
    isDeclareInterface(props?: object | null): this is NodePath<t.DeclareInterface>;
    isDeclareModule(props?: object | null): this is NodePath<t.DeclareModule>;
    isDeclareModuleExports(props?: object | null): this is NodePath<t.DeclareModuleExports>;
    isDeclareOpaqueType(props?: object | null): this is NodePath<t.DeclareOpaqueType>;
    isDeclareTypeAlias(props?: object | null): this is NodePath<t.DeclareTypeAlias>;
    isDeclareVariable(props?: object | null): this is NodePath<t.DeclareVariable>;
    isDeclaredPredicate(props?: object | null): this is NodePath<t.DeclaredPredicate>;
    isDecorator(props?: object | null): this is NodePath<t.Decorator>;
    isDirective(props?: object | null): this is NodePath<t.Directive>;
    isDirectiveLiteral(props?: object | null): this is NodePath<t.DirectiveLiteral>;
    isDoExpression(props?: object | null): this is NodePath<t.DoExpression>;
    isDoWhileStatement(props?: object | null): this is NodePath<t.DoWhileStatement>;
    isEmptyStatement(props?: object | null): this is NodePath<t.EmptyStatement>;
    isEmptyTypeAnnotation(props?: object | null): this is NodePath<t.EmptyTypeAnnotation>;
    isExistsTypeAnnotation(props?: object | null): this is NodePath<t.ExistsTypeAnnotation>;
    isExportAllDeclaration(props?: object | null): this is NodePath<t.ExportAllDeclaration>;
    isExportDeclaration(props?: object | null): this is NodePath<t.ExportDeclaration>;
    isExportDefaultDeclaration(props?: object | null): this is NodePath<t.ExportDefaultDeclaration>;
    isExportDefaultSpecifier(props?: object | null): this is NodePath<t.ExportDefaultSpecifier>;
    isExportNamedDeclaration(props?: object | null): this is NodePath<t.ExportNamedDeclaration>;
    isExportNamespaceSpecifier(props?: object | null): this is NodePath<t.ExportNamespaceSpecifier>;
    isExportSpecifier(props?: object | null): this is NodePath<t.ExportSpecifier>;
    isExpression(props?: object | null): this is NodePath<t.Expression>;
    isExpressionStatement(props?: object | null): this is NodePath<t.ExpressionStatement>;
    isExpressionWrapper(props?: object | null): this is NodePath<t.ExpressionWrapper>;
    isFile(props?: object | null): this is NodePath<t.File>;
    isFlow(props?: object | null): this is NodePath<t.Flow>;
    isFlowBaseAnnotation(props?: object | null): this is NodePath<t.FlowBaseAnnotation>;
    isFlowDeclaration(props?: object | null): this is NodePath<t.FlowDeclaration>;
    isFlowPredicate(props?: object | null): this is NodePath<t.FlowPredicate>;
    isFlowType(props?: object | null): this is NodePath<t.FlowType>;
    isFor(props?: object | null): this is NodePath<t.For>;
    isForInStatement(props?: object | null): this is NodePath<t.ForInStatement>;
    isForOfStatement(props?: object | null): this is NodePath<t.ForOfStatement>;
    isForStatement(props?: object | null): this is NodePath<t.ForStatement>;
    isForXStatement(props?: object | null): this is NodePath<t.ForXStatement>;
    isFunction(props?: object | null): this is NodePath<t.Function>;
    isFunctionDeclaration(props?: object | null): this is NodePath<t.FunctionDeclaration>;
    isFunctionExpression(props?: object | null): this is NodePath<t.FunctionExpression>;
    isFunctionParent(props?: object | null): this is NodePath<t.FunctionParent>;
    isFunctionTypeAnnotation(props?: object | null): this is NodePath<t.FunctionTypeAnnotation>;
    isFunctionTypeParam(props?: object | null): this is NodePath<t.FunctionTypeParam>;
    isGenericTypeAnnotation(props?: object | null): this is NodePath<t.GenericTypeAnnotation>;
    isIdentifier(props?: object | null): this is NodePath<t.Identifier>;
    isIfStatement(props?: object | null): this is NodePath<t.IfStatement>;
    isImmutable(props?: object | null): this is NodePath<t.Immutable>;
    isImport(props?: object | null): this is NodePath<t.Import>;
    isImportDeclaration(props?: object | null): this is NodePath<t.ImportDeclaration>;
    isImportDefaultSpecifier(props?: object | null): this is NodePath<t.ImportDefaultSpecifier>;
    isImportNamespaceSpecifier(props?: object | null): this is NodePath<t.ImportNamespaceSpecifier>;
    isImportSpecifier(props?: object | null): this is NodePath<t.ImportSpecifier>;
    isInferredPredicate(props?: object | null): this is NodePath<t.InferredPredicate>;
    isInterfaceDeclaration(props?: object | null): this is NodePath<t.InterfaceDeclaration>;
    isInterfaceExtends(props?: object | null): this is NodePath<t.InterfaceExtends>;
    isInterfaceTypeAnnotation(props?: object | null): this is NodePath<t.InterfaceTypeAnnotation>;
    isInterpreterDirective(props?: object | null): this is NodePath<t.InterpreterDirective>;
    isIntersectionTypeAnnotation(props?: object | null): this is NodePath<t.IntersectionTypeAnnotation>;
    isJSX(props?: object | null): this is NodePath<t.JSX>;
    isJSXAttribute(props?: object | null): this is NodePath<t.JSXAttribute>;
    isJSXClosingElement(props?: object | null): this is NodePath<t.JSXClosingElement>;
    isJSXClosingFragment(props?: object | null): this is NodePath<t.JSXClosingFragment>;
    isJSXElement(props?: object | null): this is NodePath<t.JSXElement>;
    isJSXEmptyExpression(props?: object | null): this is NodePath<t.JSXEmptyExpression>;
    isJSXExpressionContainer(props?: object | null): this is NodePath<t.JSXExpressionContainer>;
    isJSXFragment(props?: object | null): this is NodePath<t.JSXFragment>;
    isJSXIdentifier(props?: object | null): this is NodePath<t.JSXIdentifier>;
    isJSXMemberExpression(props?: object | null): this is NodePath<t.JSXMemberExpression>;
    isJSXNamespacedName(props?: object | null): this is NodePath<t.JSXNamespacedName>;
    isJSXOpeningElement(props?: object | null): this is NodePath<t.JSXOpeningElement>;
    isJSXOpeningFragment(props?: object | null): this is NodePath<t.JSXOpeningFragment>;
    isJSXSpreadAttribute(props?: object | null): this is NodePath<t.JSXSpreadAttribute>;
    isJSXSpreadChild(props?: object | null): this is NodePath<t.JSXSpreadChild>;
    isJSXText(props?: object | null): this is NodePath<t.JSXText>;
    isLVal(props?: object | null): this is NodePath<t.LVal>;
    isLabeledStatement(props?: object | null): this is NodePath<t.LabeledStatement>;
    isLiteral(props?: object | null): this is NodePath<t.Literal>;
    isLogicalExpression(props?: object | null): this is NodePath<t.LogicalExpression>;
    isLoop(props?: object | null): this is NodePath<t.Loop>;
    isMemberExpression(props?: object | null): this is NodePath<t.MemberExpression>;
    isMetaProperty(props?: object | null): this is NodePath<t.MetaProperty>;
    isMethod(props?: object | null): this is NodePath<t.Method>;
    isMixedTypeAnnotation(props?: object | null): this is NodePath<t.MixedTypeAnnotation>;
    isModuleDeclaration(props?: object | null): this is NodePath<t.ModuleDeclaration>;
    isModuleSpecifier(props?: object | null): this is NodePath<t.ModuleSpecifier>;
    isNewExpression(props?: object | null): this is NodePath<t.NewExpression>;
    isNoop(props?: object | null): this is NodePath<t.Noop>;
    isNullLiteral(props?: object | null): this is NodePath<t.NullLiteral>;
    isNullLiteralTypeAnnotation(props?: object | null): this is NodePath<t.NullLiteralTypeAnnotation>;
    isNullableTypeAnnotation(props?: object | null): this is NodePath<t.NullableTypeAnnotation>;

    /** @deprecated Use `isNumericLiteral` */
    isNumberLiteral(props?: object | null): this is NodePath<t.NumericLiteral>;
    isNumberLiteralTypeAnnotation(props?: object | null): this is NodePath<t.NumberLiteralTypeAnnotation>;
    isNumberTypeAnnotation(props?: object | null): this is NodePath<t.NumberTypeAnnotation>;
    isNumericLiteral(props?: object | null): this is NodePath<t.NumericLiteral>;
    isObjectExpression(props?: object | null): this is NodePath<t.ObjectExpression>;
    isObjectMember(props?: object | null): this is NodePath<t.ObjectMember>;
    isObjectMethod(props?: object | null): this is NodePath<t.ObjectMethod>;
    isObjectPattern(props?: object | null): this is NodePath<t.ObjectPattern>;
    isObjectProperty(props?: object | null): this is NodePath<t.ObjectProperty>;
    isObjectTypeAnnotation(props?: object | null): this is NodePath<t.ObjectTypeAnnotation>;
    isObjectTypeCallProperty(props?: object | null): this is NodePath<t.ObjectTypeCallProperty>;
    isObjectTypeIndexer(props?: object | null): this is NodePath<t.ObjectTypeIndexer>;
    isObjectTypeInternalSlot(props?: object | null): this is NodePath<t.ObjectTypeInternalSlot>;
    isObjectTypeProperty(props?: object | null): this is NodePath<t.ObjectTypeProperty>;
    isObjectTypeSpreadProperty(props?: object | null): this is NodePath<t.ObjectTypeSpreadProperty>;
    isOpaqueType(props?: object | null): this is NodePath<t.OpaqueType>;
    isOptionalCallExpression(props?: object | null): this is NodePath<t.OptionalCallExpression>;
    isOptionalMemberExpression(props?: object | null): this is NodePath<t.OptionalMemberExpression>;
    isParenthesizedExpression(props?: object | null): this is NodePath<t.ParenthesizedExpression>;
    isPattern(props?: object | null): this is NodePath<t.Pattern>;
    isPatternLike(props?: object | null): this is NodePath<t.PatternLike>;
    isPipelineBareFunction(props?: object | null): this is NodePath<t.PipelineBareFunction>;
    isPipelinePrimaryTopicReference(props?: object | null): this is NodePath<t.PipelinePrimaryTopicReference>;
    isPipelineTopicExpression(props?: object | null): this is NodePath<t.PipelineTopicExpression>;
    isPrivate(props?: object | null): this is NodePath<t.Private>;
    isPrivateName(props?: object | null): this is NodePath<t.PrivateName>;
    isProgram(props?: object | null): this is NodePath<t.Program>;
    isProperty(props?: object | null): this is NodePath<t.Property>;
    isPureish(props?: object | null): this is NodePath<t.Pureish>;
    isQualifiedTypeIdentifier(props?: object | null): this is NodePath<t.QualifiedTypeIdentifier>;
    isRegExpLiteral(props?: object | null): this is NodePath<t.RegExpLiteral>;

    /** @deprecated Use `isRegExpLiteral` */
    isRegexLiteral(props?: object | null): this is NodePath<t.RegExpLiteral>;
    isRestElement(props?: object | null): this is NodePath<t.RestElement>;

    /** @deprecated Use `isRestElement` */
    isRestProperty(props?: object | null): this is NodePath<t.RestElement>;
    isReturnStatement(props?: object | null): this is NodePath<t.ReturnStatement>;
    isScopable(props?: object | null): this is NodePath<t.Scopable>;
    isSequenceExpression(props?: object | null): this is NodePath<t.SequenceExpression>;
    isSpreadElement(props?: object | null): this is NodePath<t.SpreadElement>;

    /** @deprecated Use `isSpreadElement` */
    isSpreadProperty(props?: object | null): this is NodePath<t.SpreadElement>;
    isStatement(props?: object | null): this is NodePath<t.Statement>;
    isStringLiteral(props?: object | null): this is NodePath<t.StringLiteral>;
    isStringLiteralTypeAnnotation(props?: object | null): this is NodePath<t.StringLiteralTypeAnnotation>;
    isStringTypeAnnotation(props?: object | null): this is NodePath<t.StringTypeAnnotation>;
    isSuper(props?: object | null): this is NodePath<t.Super>;
    isSwitchCase(props?: object | null): this is NodePath<t.SwitchCase>;
    isSwitchStatement(props?: object | null): this is NodePath<t.SwitchStatement>;
    isTSAnyKeyword(props?: object | null): this is NodePath<t.TSAnyKeyword>;
    isTSArrayType(props?: object | null): this is NodePath<t.TSArrayType>;
    isTSAsExpression(props?: object | null): this is NodePath<t.TSAsExpression>;
    isTSBooleanKeyword(props?: object | null): this is NodePath<t.TSBooleanKeyword>;
    isTSCallSignatureDeclaration(props?: object | null): this is NodePath<t.TSCallSignatureDeclaration>;
    isTSConditionalType(props?: object | null): this is NodePath<t.TSConditionalType>;
    isTSConstructSignatureDeclaration(props?: object | null): this is NodePath<t.TSConstructSignatureDeclaration>;
    isTSConstructorType(props?: object | null): this is NodePath<t.TSConstructorType>;
    isTSDeclareFunction(props?: object | null): this is NodePath<t.TSDeclareFunction>;
    isTSDeclareMethod(props?: object | null): this is NodePath<t.TSDeclareMethod>;
    isTSEntityName(props?: object | null): this is NodePath<t.TSEntityName>;
    isTSEnumDeclaration(props?: object | null): this is NodePath<t.TSEnumDeclaration>;
    isTSEnumMember(props?: object | null): this is NodePath<t.TSEnumMember>;
    isTSExportAssignment(props?: object | null): this is NodePath<t.TSExportAssignment>;
    isTSExpressionWithTypeArguments(props?: object | null): this is NodePath<t.TSExpressionWithTypeArguments>;
    isTSExternalModuleReference(props?: object | null): this is NodePath<t.TSExternalModuleReference>;
    isTSFunctionType(props?: object | null): this is NodePath<t.TSFunctionType>;
    isTSImportEqualsDeclaration(props?: object | null): this is NodePath<t.TSImportEqualsDeclaration>;
    isTSImportType(props?: object | null): this is NodePath<t.TSImportType>;
    isTSIndexSignature(props?: object | null): this is NodePath<t.TSIndexSignature>;
    isTSIndexedAccessType(props?: object | null): this is NodePath<t.TSIndexedAccessType>;
    isTSInferType(props?: object | null): this is NodePath<t.TSInferType>;
    isTSInterfaceBody(props?: object | null): this is NodePath<t.TSInterfaceBody>;
    isTSInterfaceDeclaration(props?: object | null): this is NodePath<t.TSInterfaceDeclaration>;
    isTSIntersectionType(props?: object | null): this is NodePath<t.TSIntersectionType>;
    isTSLiteralType(props?: object | null): this is NodePath<t.TSLiteralType>;
    isTSMappedType(props?: object | null): this is NodePath<t.TSMappedType>;
    isTSMethodSignature(props?: object | null): this is NodePath<t.TSMethodSignature>;
    isTSModuleBlock(props?: object | null): this is NodePath<t.TSModuleBlock>;
    isTSModuleDeclaration(props?: object | null): this is NodePath<t.TSModuleDeclaration>;
    isTSNamespaceExportDeclaration(props?: object | null): this is NodePath<t.TSNamespaceExportDeclaration>;
    isTSNeverKeyword(props?: object | null): this is NodePath<t.TSNeverKeyword>;
    isTSNonNullExpression(props?: object | null): this is NodePath<t.TSNonNullExpression>;
    isTSNullKeyword(props?: object | null): this is NodePath<t.TSNullKeyword>;
    isTSNumberKeyword(props?: object | null): this is NodePath<t.TSNumberKeyword>;
    isTSObjectKeyword(props?: object | null): this is NodePath<t.TSObjectKeyword>;
    isTSOptionalType(props?: object | null): this is NodePath<t.TSOptionalType>;
    isTSParameterProperty(props?: object | null): this is NodePath<t.TSParameterProperty>;
    isTSParenthesizedType(props?: object | null): this is NodePath<t.TSParenthesizedType>;
    isTSPropertySignature(props?: object | null): this is NodePath<t.TSPropertySignature>;
    isTSQualifiedName(props?: object | null): this is NodePath<t.TSQualifiedName>;
    isTSRestType(props?: object | null): this is NodePath<t.TSRestType>;
    isTSStringKeyword(props?: object | null): this is NodePath<t.TSStringKeyword>;
    isTSSymbolKeyword(props?: object | null): this is NodePath<t.TSSymbolKeyword>;
    isTSThisType(props?: object | null): this is NodePath<t.TSThisType>;
    isTSTupleType(props?: object | null): this is NodePath<t.TSTupleType>;
    isTSType(props?: object | null): this is NodePath<t.TSType>;
    isTSTypeAliasDeclaration(props?: object | null): this is NodePath<t.TSTypeAliasDeclaration>;
    isTSTypeAnnotation(props?: object | null): this is NodePath<t.TSTypeAnnotation>;
    isTSTypeAssertion(props?: object | null): this is NodePath<t.TSTypeAssertion>;
    isTSTypeElement(props?: object | null): this is NodePath<t.TSTypeElement>;
    isTSTypeLiteral(props?: object | null): this is NodePath<t.TSTypeLiteral>;
    isTSTypeOperator(props?: object | null): this is NodePath<t.TSTypeOperator>;
    isTSTypeParameter(props?: object | null): this is NodePath<t.TSTypeParameter>;
    isTSTypeParameterDeclaration(props?: object | null): this is NodePath<t.TSTypeParameterDeclaration>;
    isTSTypeParameterInstantiation(props?: object | null): this is NodePath<t.TSTypeParameterInstantiation>;
    isTSTypePredicate(props?: object | null): this is NodePath<t.TSTypePredicate>;
    isTSTypeQuery(props?: object | null): this is NodePath<t.TSTypeQuery>;
    isTSTypeReference(props?: object | null): this is NodePath<t.TSTypeReference>;
    isTSUndefinedKeyword(props?: object | null): this is NodePath<t.TSUndefinedKeyword>;
    isTSUnionType(props?: object | null): this is NodePath<t.TSUnionType>;
    isTSUnknownKeyword(props?: object | null): this is NodePath<t.TSUnknownKeyword>;
    isTSVoidKeyword(props?: object | null): this is NodePath<t.TSVoidKeyword>;
    isTaggedTemplateExpression(props?: object | null): this is NodePath<t.TaggedTemplateExpression>;
    isTemplateElement(props?: object | null): this is NodePath<t.TemplateElement>;
    isTemplateLiteral(props?: object | null): this is NodePath<t.TemplateLiteral>;
    isTerminatorless(props?: object | null): this is NodePath<t.Terminatorless>;
    isThisExpression(props?: object | null): this is NodePath<t.ThisExpression>;
    isThisTypeAnnotation(props?: object | null): this is NodePath<t.ThisTypeAnnotation>;
    isThrowStatement(props?: object | null): this is NodePath<t.ThrowStatement>;
    isTryStatement(props?: object | null): this is NodePath<t.TryStatement>;
    isTupleTypeAnnotation(props?: object | null): this is NodePath<t.TupleTypeAnnotation>;
    isTypeAlias(props?: object | null): this is NodePath<t.TypeAlias>;
    isTypeAnnotation(props?: object | null): this is NodePath<t.TypeAnnotation>;
    isTypeCastExpression(props?: object | null): this is NodePath<t.TypeCastExpression>;
    isTypeParameter(props?: object | null): this is NodePath<t.TypeParameter>;
    isTypeParameterDeclaration(props?: object | null): this is NodePath<t.TypeParameterDeclaration>;
    isTypeParameterInstantiation(props?: object | null): this is NodePath<t.TypeParameterInstantiation>;
    isTypeofTypeAnnotation(props?: object | null): this is NodePath<t.TypeofTypeAnnotation>;
    isUnaryExpression(props?: object | null): this is NodePath<t.UnaryExpression>;
    isUnaryLike(props?: object | null): this is NodePath<t.UnaryLike>;
    isUnionTypeAnnotation(props?: object | null): this is NodePath<t.UnionTypeAnnotation>;
    isUpdateExpression(props?: object | null): this is NodePath<t.UpdateExpression>;
    isUserWhitespacable(props?: object | null): this is NodePath<t.UserWhitespacable>;
    isVariableDeclaration(props?: object | null): this is NodePath<t.VariableDeclaration>;
    isVariableDeclarator(props?: object | null): this is NodePath<t.VariableDeclarator>;
    isVariance(props?: object | null): this is NodePath<t.Variance>;
    isVoidTypeAnnotation(props?: object | null): this is NodePath<t.VoidTypeAnnotation>;
    isWhile(props?: object | null): this is NodePath<t.While>;
    isWhileStatement(props?: object | null): this is NodePath<t.WhileStatement>;
    isWithStatement(props?: object | null): this is NodePath<t.WithStatement>;
    isYieldExpression(props?: object | null): this is NodePath<t.YieldExpression>;

    isBindingIdentifier(props?: object | null): this is NodePath<t.Identifier>;
    isBlockScoped(
        props?: object | null,
    ): this is NodePath<t.FunctionDeclaration | t.ClassDeclaration | t.VariableDeclaration>;
    isGenerated(props?: object | null): boolean;
    isPure(props?: object | null): boolean;
    isReferenced(props?: object | null): boolean;
    isReferencedIdentifier(props?: object | null): this is NodePath<t.Identifier | t.JSXIdentifier>;
    isReferencedMemberExpression(props?: object | null): this is NodePath<t.MemberExpression>;
    isScope(props?: object | null): this is NodePath<t.Scopable>;
    isUser(props?: object | null): boolean;
    isVar(props?: object | null): this is NodePath<t.VariableDeclaration>;
    //#endregion

    //#region ------------------------- assertXXX -------------------------
    assertAnyTypeAnnotation(props?: object | null): void;
    assertArrayExpression(props?: object | null): void;
    assertArrayPattern(props?: object | null): void;
    assertArrayTypeAnnotation(props?: object | null): void;
    assertArrowFunctionExpression(props?: object | null): void;
    assertAssignmentExpression(props?: object | null): void;
    assertAssignmentPattern(props?: object | null): void;
    assertAwaitExpression(props?: object | null): void;
    assertBigIntLiteral(props?: object | null): void;
    assertBinary(props?: object | null): void;
    assertBinaryExpression(props?: object | null): void;
    assertBindExpression(props?: object | null): void;
    assertBlock(props?: object | null): void;
    assertBlockParent(props?: object | null): void;
    assertBlockStatement(props?: object | null): void;
    assertBooleanLiteral(props?: object | null): void;
    assertBooleanLiteralTypeAnnotation(props?: object | null): void;
    assertBooleanTypeAnnotation(props?: object | null): void;
    assertBreakStatement(props?: object | null): void;
    assertCallExpression(props?: object | null): void;
    assertCatchClause(props?: object | null): void;
    assertClass(props?: object | null): void;
    assertClassBody(props?: object | null): void;
    assertClassDeclaration(props?: object | null): void;
    assertClassExpression(props?: object | null): void;
    assertClassImplements(props?: object | null): void;
    assertClassMethod(props?: object | null): void;
    assertClassPrivateMethod(props?: object | null): void;
    assertClassPrivateProperty(props?: object | null): void;
    assertClassProperty(props?: object | null): void;
    assertCompletionStatement(props?: object | null): void;
    assertConditional(props?: object | null): void;
    assertConditionalExpression(props?: object | null): void;
    assertContinueStatement(props?: object | null): void;
    assertDebuggerStatement(props?: object | null): void;
    assertDeclaration(props?: object | null): void;
    assertDeclareClass(props?: object | null): void;
    assertDeclareExportAllDeclaration(props?: object | null): void;
    assertDeclareExportDeclaration(props?: object | null): void;
    assertDeclareFunction(props?: object | null): void;
    assertDeclareInterface(props?: object | null): void;
    assertDeclareModule(props?: object | null): void;
    assertDeclareModuleExports(props?: object | null): void;
    assertDeclareOpaqueType(props?: object | null): void;
    assertDeclareTypeAlias(props?: object | null): void;
    assertDeclareVariable(props?: object | null): void;
    assertDeclaredPredicate(props?: object | null): void;
    assertDecorator(props?: object | null): void;
    assertDirective(props?: object | null): void;
    assertDirectiveLiteral(props?: object | null): void;
    assertDoExpression(props?: object | null): void;
    assertDoWhileStatement(props?: object | null): void;
    assertEmptyStatement(props?: object | null): void;
    assertEmptyTypeAnnotation(props?: object | null): void;
    assertExistsTypeAnnotation(props?: object | null): void;
    assertExportAllDeclaration(props?: object | null): void;
    assertExportDeclaration(props?: object | null): void;
    assertExportDefaultDeclaration(props?: object | null): void;
    assertExportDefaultSpecifier(props?: object | null): void;
    assertExportNamedDeclaration(props?: object | null): void;
    assertExportNamespaceSpecifier(props?: object | null): void;
    assertExportSpecifier(props?: object | null): void;
    assertExpression(props?: object | null): void;
    assertExpressionStatement(props?: object | null): void;
    assertExpressionWrapper(props?: object | null): void;
    assertFile(props?: object | null): void;
    assertFlow(props?: object | null): void;
    assertFlowBaseAnnotation(props?: object | null): void;
    assertFlowDeclaration(props?: object | null): void;
    assertFlowPredicate(props?: object | null): void;
    assertFlowType(props?: object | null): void;
    assertFor(props?: object | null): void;
    assertForInStatement(props?: object | null): void;
    assertForOfStatement(props?: object | null): void;
    assertForStatement(props?: object | null): void;
    assertForXStatement(props?: object | null): void;
    assertFunction(props?: object | null): void;
    assertFunctionDeclaration(props?: object | null): void;
    assertFunctionExpression(props?: object | null): void;
    assertFunctionParent(props?: object | null): void;
    assertFunctionTypeAnnotation(props?: object | null): void;
    assertFunctionTypeParam(props?: object | null): void;
    assertGenericTypeAnnotation(props?: object | null): void;
    assertIdentifier(props?: object | null): void;
    assertIfStatement(props?: object | null): void;
    assertImmutable(props?: object | null): void;
    assertImport(props?: object | null): void;
    assertImportDeclaration(props?: object | null): void;
    assertImportDefaultSpecifier(props?: object | null): void;
    assertImportNamespaceSpecifier(props?: object | null): void;
    assertImportSpecifier(props?: object | null): void;
    assertInferredPredicate(props?: object | null): void;
    assertInterfaceDeclaration(props?: object | null): void;
    assertInterfaceExtends(props?: object | null): void;
    assertInterfaceTypeAnnotation(props?: object | null): void;
    assertInterpreterDirective(props?: object | null): void;
    assertIntersectionTypeAnnotation(props?: object | null): void;
    assertJSX(props?: object | null): void;
    assertJSXAttribute(props?: object | null): void;
    assertJSXClosingElement(props?: object | null): void;
    assertJSXClosingFragment(props?: object | null): void;
    assertJSXElement(props?: object | null): void;
    assertJSXEmptyExpression(props?: object | null): void;
    assertJSXExpressionContainer(props?: object | null): void;
    assertJSXFragment(props?: object | null): void;
    assertJSXIdentifier(props?: object | null): void;
    assertJSXMemberExpression(props?: object | null): void;
    assertJSXNamespacedName(props?: object | null): void;
    assertJSXOpeningElement(props?: object | null): void;
    assertJSXOpeningFragment(props?: object | null): void;
    assertJSXSpreadAttribute(props?: object | null): void;
    assertJSXSpreadChild(props?: object | null): void;
    assertJSXText(props?: object | null): void;
    assertLVal(props?: object | null): void;
    assertLabeledStatement(props?: object | null): void;
    assertLiteral(props?: object | null): void;
    assertLogicalExpression(props?: object | null): void;
    assertLoop(props?: object | null): void;
    assertMemberExpression(props?: object | null): void;
    assertMetaProperty(props?: object | null): void;
    assertMethod(props?: object | null): void;
    assertMixedTypeAnnotation(props?: object | null): void;
    assertModuleDeclaration(props?: object | null): void;
    assertModuleSpecifier(props?: object | null): void;
    assertNewExpression(props?: object | null): void;
    assertNoop(props?: object | null): void;
    assertNullLiteral(props?: object | null): void;
    assertNullLiteralTypeAnnotation(props?: object | null): void;
    assertNullableTypeAnnotation(props?: object | null): void;

    /** @deprecated Use `assertNumericLiteral` */
    assertNumberLiteral(props?: object | null): void;
    assertNumberLiteralTypeAnnotation(props?: object | null): void;
    assertNumberTypeAnnotation(props?: object | null): void;
    assertNumericLiteral(props?: object | null): void;
    assertObjectExpression(props?: object | null): void;
    assertObjectMember(props?: object | null): void;
    assertObjectMethod(props?: object | null): void;
    assertObjectPattern(props?: object | null): void;
    assertObjectProperty(props?: object | null): void;
    assertObjectTypeAnnotation(props?: object | null): void;
    assertObjectTypeCallProperty(props?: object | null): void;
    assertObjectTypeIndexer(props?: object | null): void;
    assertObjectTypeInternalSlot(props?: object | null): void;
    assertObjectTypeProperty(props?: object | null): void;
    assertObjectTypeSpreadProperty(props?: object | null): void;
    assertOpaqueType(props?: object | null): void;
    assertOptionalCallExpression(props?: object | null): void;
    assertOptionalMemberExpression(props?: object | null): void;
    assertParenthesizedExpression(props?: object | null): void;
    assertPattern(props?: object | null): void;
    assertPatternLike(props?: object | null): void;
    assertPipelineBareFunction(props?: object | null): void;
    assertPipelinePrimaryTopicReference(props?: object | null): void;
    assertPipelineTopicExpression(props?: object | null): void;
    assertPrivate(props?: object | null): void;
    assertPrivateName(props?: object | null): void;
    assertProgram(props?: object | null): void;
    assertProperty(props?: object | null): void;
    assertPureish(props?: object | null): void;
    assertQualifiedTypeIdentifier(props?: object | null): void;
    assertRegExpLiteral(props?: object | null): void;

    /** @deprecated Use `assertRegExpLiteral` */
    assertRegexLiteral(props?: object | null): void;
    assertRestElement(props?: object | null): void;

    /** @deprecated Use `assertRestElement` */
    assertRestProperty(props?: object | null): void;
    assertReturnStatement(props?: object | null): void;
    assertScopable(props?: object | null): void;
    assertSequenceExpression(props?: object | null): void;
    assertSpreadElement(props?: object | null): void;

    /** @deprecated Use `assertSpreadElement` */
    assertSpreadProperty(props?: object | null): void;
    assertStatement(props?: object | null): void;
    assertStringLiteral(props?: object | null): void;
    assertStringLiteralTypeAnnotation(props?: object | null): void;
    assertStringTypeAnnotation(props?: object | null): void;
    assertSuper(props?: object | null): void;
    assertSwitchCase(props?: object | null): void;
    assertSwitchStatement(props?: object | null): void;
    assertTSAnyKeyword(props?: object | null): void;
    assertTSArrayType(props?: object | null): void;
    assertTSAsExpression(props?: object | null): void;
    assertTSBooleanKeyword(props?: object | null): void;
    assertTSCallSignatureDeclaration(props?: object | null): void;
    assertTSConditionalType(props?: object | null): void;
    assertTSConstructSignatureDeclaration(props?: object | null): void;
    assertTSConstructorType(props?: object | null): void;
    assertTSDeclareFunction(props?: object | null): void;
    assertTSDeclareMethod(props?: object | null): void;
    assertTSEntityName(props?: object | null): void;
    assertTSEnumDeclaration(props?: object | null): void;
    assertTSEnumMember(props?: object | null): void;
    assertTSExportAssignment(props?: object | null): void;
    assertTSExpressionWithTypeArguments(props?: object | null): void;
    assertTSExternalModuleReference(props?: object | null): void;
    assertTSFunctionType(props?: object | null): void;
    assertTSImportEqualsDeclaration(props?: object | null): void;
    assertTSImportType(props?: object | null): void;
    assertTSIndexSignature(props?: object | null): void;
    assertTSIndexedAccessType(props?: object | null): void;
    assertTSInferType(props?: object | null): void;
    assertTSInterfaceBody(props?: object | null): void;
    assertTSInterfaceDeclaration(props?: object | null): void;
    assertTSIntersectionType(props?: object | null): void;
    assertTSLiteralType(props?: object | null): void;
    assertTSMappedType(props?: object | null): void;
    assertTSMethodSignature(props?: object | null): void;
    assertTSModuleBlock(props?: object | null): void;
    assertTSModuleDeclaration(props?: object | null): void;
    assertTSNamespaceExportDeclaration(props?: object | null): void;
    assertTSNeverKeyword(props?: object | null): void;
    assertTSNonNullExpression(props?: object | null): void;
    assertTSNullKeyword(props?: object | null): void;
    assertTSNumberKeyword(props?: object | null): void;
    assertTSObjectKeyword(props?: object | null): void;
    assertTSOptionalType(props?: object | null): void;
    assertTSParameterProperty(props?: object | null): void;
    assertTSParenthesizedType(props?: object | null): void;
    assertTSPropertySignature(props?: object | null): void;
    assertTSQualifiedName(props?: object | null): void;
    assertTSRestType(props?: object | null): void;
    assertTSStringKeyword(props?: object | null): void;
    assertTSSymbolKeyword(props?: object | null): void;
    assertTSThisType(props?: object | null): void;
    assertTSTupleType(props?: object | null): void;
    assertTSType(props?: object | null): void;
    assertTSTypeAliasDeclaration(props?: object | null): void;
    assertTSTypeAnnotation(props?: object | null): void;
    assertTSTypeAssertion(props?: object | null): void;
    assertTSTypeElement(props?: object | null): void;
    assertTSTypeLiteral(props?: object | null): void;
    assertTSTypeOperator(props?: object | null): void;
    assertTSTypeParameter(props?: object | null): void;
    assertTSTypeParameterDeclaration(props?: object | null): void;
    assertTSTypeParameterInstantiation(props?: object | null): void;
    assertTSTypePredicate(props?: object | null): void;
    assertTSTypeQuery(props?: object | null): void;
    assertTSTypeReference(props?: object | null): void;
    assertTSUndefinedKeyword(props?: object | null): void;
    assertTSUnionType(props?: object | null): void;
    assertTSUnknownKeyword(props?: object | null): void;
    assertTSVoidKeyword(props?: object | null): void;
    assertTaggedTemplateExpression(props?: object | null): void;
    assertTemplateElement(props?: object | null): void;
    assertTemplateLiteral(props?: object | null): void;
    assertTerminatorless(props?: object | null): void;
    assertThisExpression(props?: object | null): void;
    assertThisTypeAnnotation(props?: object | null): void;
    assertThrowStatement(props?: object | null): void;
    assertTryStatement(props?: object | null): void;
    assertTupleTypeAnnotation(props?: object | null): void;
    assertTypeAlias(props?: object | null): void;
    assertTypeAnnotation(props?: object | null): void;
    assertTypeCastExpression(props?: object | null): void;
    assertTypeParameter(props?: object | null): void;
    assertTypeParameterDeclaration(props?: object | null): void;
    assertTypeParameterInstantiation(props?: object | null): void;
    assertTypeofTypeAnnotation(props?: object | null): void;
    assertUnaryExpression(props?: object | null): void;
    assertUnaryLike(props?: object | null): void;
    assertUnionTypeAnnotation(props?: object | null): void;
    assertUpdateExpression(props?: object | null): void;
    assertUserWhitespacable(props?: object | null): void;
    assertVariableDeclaration(props?: object | null): void;
    assertVariableDeclarator(props?: object | null): void;
    assertVariance(props?: object | null): void;
    assertVoidTypeAnnotation(props?: object | null): void;
    assertWhile(props?: object | null): void;
    assertWhileStatement(props?: object | null): void;
    assertWithStatement(props?: object | null): void;
    assertYieldExpression(props?: object | null): void;

    assertBindingIdentifier(props?: object | null): void;
    assertBlockScoped(props?: object | null): void;
    assertGenerated(props?: object | null): void;
    assertPure(props?: object | null): void;
    assertReferenced(props?: object | null): void;
    assertReferencedIdentifier(props?: object | null): void;
    assertReferencedMemberExpression(props?: object | null): void;
    assertScope(props?: object | null): void;
    assertUser(props?: object | null): void;
    assertVar(props?: object | null): void;
    //#endregion
}

export interface HubInterface {
    getCode(): string | undefined;
    getScope(): Scope | undefined;
    addHelper(name: string): any;
    buildError<E extends Error>(node: Node, msg: string, Error: new (message?: string) => E): E;
}

export class Hub implements HubInterface {
    constructor();
    getCode(): string | undefined;
    getScope(): Scope | undefined;
    addHelper(name: string): any;
    buildError<E extends Error>(node: Node, msg: string, Constructor: new (message?: string) => E): E;
}

export interface TraversalContext {
    parentPath: NodePath;
    scope: Scope;
    state: any;
    opts: any;
}
