// Type definitions for babel-traverse v6.7
// Project: https://github.com/babel/babel/tree/master/packages/babel-traverse
// Definitions by: Troy Gerwien <https://github.com/yortus>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped

/// <reference path="../babel-types/babel-types.d.ts" />

declare module "babel-traverse" {
    import * as t from 'babel-types';
    type Node = t.Node;

    export default function traverse(parent: Node | Node[], opts?: TraverseOptions, scope?: Scope, state?: any, parentPath?: NodePath<Node>): void;

    export interface TraverseOptions extends Visitor {
        scope?: Scope;
        noScope?: boolean;
    }

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

        /** Traverse node with current scope and path. */
        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: Node, kind: string, name: string, id: Object): void;

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

        dump(): void;

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

        registerDeclaration(path: NodePath<Node>): void;

        buildUndefinedNode(): Node;

        registerConstantViolation(path: NodePath<Node>): void;

        registerBinding(kind: string, path: NodePath<Node>, bindingPath?: NodePath<Node>): 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;

        push(opts: any): void;

        getProgramParent(): Scope;

        getFunctionParent(): Scope;

        getBlockParent(): Scope;

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

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

        getBinding(name: string): Binding;

        getOwnBinding(name: string): Binding;

        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 class Binding {
        constructor(opts: { existing: Binding; identifier: t.Identifier; scope: Scope; path: NodePath<Node>; kind: 'var' | 'let' | 'const'; });
        identifier: t.Identifier;
        scope: Scope;
        path: NodePath<Node>;
        kind: 'var' | 'let' | 'const';
        referenced: boolean;
        references: number;
        referencePaths: NodePath<Node>[];
        constant: boolean;
        constantViolations: NodePath<Node>[];
    }

    export interface Visitor extends VisitNodeObject<Node> {
        ArrayExpression?: VisitNode<t.ArrayExpression>;
        AssignmentExpression?: VisitNode<t.AssignmentExpression>;
        LVal?: VisitNode<t.LVal>;
        Expression?: VisitNode<t.Expression>;
        BinaryExpression?: VisitNode<t.BinaryExpression>;
        Directive?: VisitNode<t.Directive>;
        DirectiveLiteral?: VisitNode<t.DirectiveLiteral>;
        BlockStatement?: VisitNode<t.BlockStatement>;
        BreakStatement?: VisitNode<t.BreakStatement>;
        Identifier?: VisitNode<t.Identifier>;
        CallExpression?: VisitNode<t.CallExpression>;
        CatchClause?: VisitNode<t.CatchClause>;
        ConditionalExpression?: VisitNode<t.ConditionalExpression>;
        ContinueStatement?: VisitNode<t.ContinueStatement>;
        DebuggerStatement?: VisitNode<t.DebuggerStatement>;
        DoWhileStatement?: VisitNode<t.DoWhileStatement>;
        Statement?: VisitNode<t.Statement>;
        EmptyStatement?: VisitNode<t.EmptyStatement>;
        ExpressionStatement?: VisitNode<t.ExpressionStatement>;
        File?: VisitNode<t.File>;
        Program?: VisitNode<t.Program>;
        ForInStatement?: VisitNode<t.ForInStatement>;
        VariableDeclaration?: VisitNode<t.VariableDeclaration>;
        ForStatement?: VisitNode<t.ForStatement>;
        FunctionDeclaration?: VisitNode<t.FunctionDeclaration>;
        FunctionExpression?: VisitNode<t.FunctionExpression>;
        IfStatement?: VisitNode<t.IfStatement>;
        LabeledStatement?: VisitNode<t.LabeledStatement>;
        StringLiteral?: VisitNode<t.StringLiteral>;
        NumericLiteral?: VisitNode<t.NumericLiteral>;
        NullLiteral?: VisitNode<t.NullLiteral>;
        BooleanLiteral?: VisitNode<t.BooleanLiteral>;
        RegExpLiteral?: VisitNode<t.RegExpLiteral>;
        LogicalExpression?: VisitNode<t.LogicalExpression>;
        MemberExpression?: VisitNode<t.MemberExpression>;
        NewExpression?: VisitNode<t.NewExpression>;
        ObjectExpression?: VisitNode<t.ObjectExpression>;
        ObjectMethod?: VisitNode<t.ObjectMethod>;
        ObjectProperty?: VisitNode<t.ObjectProperty>;
        RestElement?: VisitNode<t.RestElement>;
        ReturnStatement?: VisitNode<t.ReturnStatement>;
        SequenceExpression?: VisitNode<t.SequenceExpression>;
        SwitchCase?: VisitNode<t.SwitchCase>;
        SwitchStatement?: VisitNode<t.SwitchStatement>;
        ThisExpression?: VisitNode<t.ThisExpression>;
        ThrowStatement?: VisitNode<t.ThrowStatement>;
        TryStatement?: VisitNode<t.TryStatement>;
        UnaryExpression?: VisitNode<t.UnaryExpression>;
        UpdateExpression?: VisitNode<t.UpdateExpression>;
        VariableDeclarator?: VisitNode<t.VariableDeclarator>;
        WhileStatement?: VisitNode<t.WhileStatement>;
        WithStatement?: VisitNode<t.WithStatement>;
        AssignmentPattern?: VisitNode<t.AssignmentPattern>;
        ArrayPattern?: VisitNode<t.ArrayPattern>;
        ArrowFunctionExpression?: VisitNode<t.ArrowFunctionExpression>;
        ClassBody?: VisitNode<t.ClassBody>;
        ClassDeclaration?: VisitNode<t.ClassDeclaration>;
        ClassExpression?: VisitNode<t.ClassExpression>;
        ExportAllDeclaration?: VisitNode<t.ExportAllDeclaration>;
        ExportDefaultDeclaration?: VisitNode<t.ExportDefaultDeclaration>;
        ExportNamedDeclaration?: VisitNode<t.ExportNamedDeclaration>;
        Declaration?: VisitNode<t.Declaration>;
        ExportSpecifier?: VisitNode<t.ExportSpecifier>;
        ForOfStatement?: VisitNode<t.ForOfStatement>;
        ImportDeclaration?: VisitNode<t.ImportDeclaration>;
        ImportDefaultSpecifier?: VisitNode<t.ImportDefaultSpecifier>;
        ImportNamespaceSpecifier?: VisitNode<t.ImportNamespaceSpecifier>;
        ImportSpecifier?: VisitNode<t.ImportSpecifier>;
        MetaProperty?: VisitNode<t.MetaProperty>;
        ClassMethod?: VisitNode<t.ClassMethod>;
        ObjectPattern?: VisitNode<t.ObjectPattern>;
        SpreadElement?: VisitNode<t.SpreadElement>;
        Super?: VisitNode<t.Super>;
        TaggedTemplateExpression?: VisitNode<t.TaggedTemplateExpression>;
        TemplateLiteral?: VisitNode<t.TemplateLiteral>;
        TemplateElement?: VisitNode<t.TemplateElement>;
        YieldExpression?: VisitNode<t.YieldExpression>;
        AnyTypeAnnotation?: VisitNode<t.AnyTypeAnnotation>;
        ArrayTypeAnnotation?: VisitNode<t.ArrayTypeAnnotation>;
        BooleanTypeAnnotation?: VisitNode<t.BooleanTypeAnnotation>;
        BooleanLiteralTypeAnnotation?: VisitNode<t.BooleanLiteralTypeAnnotation>;
        NullLiteralTypeAnnotation?: VisitNode<t.NullLiteralTypeAnnotation>;
        ClassImplements?: VisitNode<t.ClassImplements>;
        ClassProperty?: VisitNode<t.ClassProperty>;
        DeclareClass?: VisitNode<t.DeclareClass>;
        DeclareFunction?: VisitNode<t.DeclareFunction>;
        DeclareInterface?: VisitNode<t.DeclareInterface>;
        DeclareModule?: VisitNode<t.DeclareModule>;
        DeclareTypeAlias?: VisitNode<t.DeclareTypeAlias>;
        DeclareVariable?: VisitNode<t.DeclareVariable>;
        ExistentialTypeParam?: VisitNode<t.ExistentialTypeParam>;
        FunctionTypeAnnotation?: VisitNode<t.FunctionTypeAnnotation>;
        FunctionTypeParam?: VisitNode<t.FunctionTypeParam>;
        GenericTypeAnnotation?: VisitNode<t.GenericTypeAnnotation>;
        InterfaceExtends?: VisitNode<t.InterfaceExtends>;
        InterfaceDeclaration?: VisitNode<t.InterfaceDeclaration>;
        IntersectionTypeAnnotation?: VisitNode<t.IntersectionTypeAnnotation>;
        MixedTypeAnnotation?: VisitNode<t.MixedTypeAnnotation>;
        NullableTypeAnnotation?: VisitNode<t.NullableTypeAnnotation>;
        NumericLiteralTypeAnnotation?: VisitNode<t.NumericLiteralTypeAnnotation>;
        NumberTypeAnnotation?: VisitNode<t.NumberTypeAnnotation>;
        StringLiteralTypeAnnotation?: VisitNode<t.StringLiteralTypeAnnotation>;
        StringTypeAnnotation?: VisitNode<t.StringTypeAnnotation>;
        ThisTypeAnnotation?: VisitNode<t.ThisTypeAnnotation>;
        TupleTypeAnnotation?: VisitNode<t.TupleTypeAnnotation>;
        TypeofTypeAnnotation?: VisitNode<t.TypeofTypeAnnotation>;
        TypeAlias?: VisitNode<t.TypeAlias>;
        TypeAnnotation?: VisitNode<t.TypeAnnotation>;
        TypeCastExpression?: VisitNode<t.TypeCastExpression>;
        TypeParameterDeclaration?: VisitNode<t.TypeParameterDeclaration>;
        TypeParameterInstantiation?: VisitNode<t.TypeParameterInstantiation>;
        ObjectTypeAnnotation?: VisitNode<t.ObjectTypeAnnotation>;
        ObjectTypeCallProperty?: VisitNode<t.ObjectTypeCallProperty>;
        ObjectTypeIndexer?: VisitNode<t.ObjectTypeIndexer>;
        ObjectTypeProperty?: VisitNode<t.ObjectTypeProperty>;
        QualifiedTypeIdentifier?: VisitNode<t.QualifiedTypeIdentifier>;
        UnionTypeAnnotation?: VisitNode<t.UnionTypeAnnotation>;
        VoidTypeAnnotation?: VisitNode<t.VoidTypeAnnotation>;
        JSXAttribute?: VisitNode<t.JSXAttribute>;
        JSXIdentifier?: VisitNode<t.JSXIdentifier>;
        JSXNamespacedName?: VisitNode<t.JSXNamespacedName>;
        JSXElement?: VisitNode<t.JSXElement>;
        JSXExpressionContainer?: VisitNode<t.JSXExpressionContainer>;
        JSXClosingElement?: VisitNode<t.JSXClosingElement>;
        JSXMemberExpression?: VisitNode<t.JSXMemberExpression>;
        JSXOpeningElement?: VisitNode<t.JSXOpeningElement>;
        JSXEmptyExpression?: VisitNode<t.JSXEmptyExpression>;
        JSXSpreadAttribute?: VisitNode<t.JSXSpreadAttribute>;
        JSXText?: VisitNode<t.JSXText>;
        Noop?: VisitNode<t.Noop>;
        ParenthesizedExpression?: VisitNode<t.ParenthesizedExpression>;
        AwaitExpression?: VisitNode<t.AwaitExpression>;
        BindExpression?: VisitNode<t.BindExpression>;
        Decorator?: VisitNode<t.Decorator>;
        DoExpression?: VisitNode<t.DoExpression>;
        ExportDefaultSpecifier?: VisitNode<t.ExportDefaultSpecifier>;
        ExportNamespaceSpecifier?: VisitNode<t.ExportNamespaceSpecifier>;
        RestProperty?: VisitNode<t.RestProperty>;
        SpreadProperty?: VisitNode<t.SpreadProperty>;
        Binary?: VisitNode<t.Binary>;
        Scopable?: VisitNode<t.Scopable>;
        BlockParent?: VisitNode<t.BlockParent>;
        Block?: VisitNode<t.Block>;
        Terminatorless?: VisitNode<t.Terminatorless>;
        CompletionStatement?: VisitNode<t.CompletionStatement>;
        Conditional?: VisitNode<t.Conditional>;
        Loop?: VisitNode<t.Loop>;
        While?: VisitNode<t.While>;
        ExpressionWrapper?: VisitNode<t.ExpressionWrapper>;
        For?: VisitNode<t.For>;
        ForXStatement?: VisitNode<t.ForXStatement>;
        Function?: VisitNode<t.Function>;
        FunctionParent?: VisitNode<t.FunctionParent>;
        Pureish?: VisitNode<t.Pureish>;
        Literal?: VisitNode<t.Literal>;
        Immutable?: VisitNode<t.Immutable>;
        UserWhitespacable?: VisitNode<t.UserWhitespacable>;
        Method?: VisitNode<t.Method>;
        ObjectMember?: VisitNode<t.ObjectMember>;
        Property?: VisitNode<t.Property>;
        UnaryLike?: VisitNode<t.UnaryLike>;
        Pattern?: VisitNode<t.Pattern>;
        Class?: VisitNode<t.Class>;
        ModuleDeclaration?: VisitNode<t.ModuleDeclaration>;
        ExportDeclaration?: VisitNode<t.ExportDeclaration>;
        ModuleSpecifier?: VisitNode<t.ModuleSpecifier>;
        Flow?: VisitNode<t.Flow>;
        FlowBaseAnnotation?: VisitNode<t.FlowBaseAnnotation>;
        FlowDeclaration?: VisitNode<t.FlowDeclaration>;
        JSX?: VisitNode<t.JSX>;
    }

    export type VisitNode<T> = VisitNodeFunction<T> | VisitNodeObject<T>;

    export type VisitNodeFunction<T> = (path: NodePath<T>, state: any) => void;

    export interface VisitNodeObject<T> {
        enter?(path: NodePath<T>, state: any): void;
        exit?(path: NodePath<T>, state: any): void;
    }

    export class NodePath<T> {
        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: NodePath<Node>;
        context: TraversalContext;
        container: Object | Object[];
        listKey: string;
        inList: boolean;
        parentKey: string;
        key: string;
        node: T;
        scope: Scope;
        type: string;
        typeAnnotation: Object;

        getScope(scope: Scope): Scope;

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

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

        buildCodeFrameError(msg: string, Error: Error): Error;

        traverse(visitor: Visitor, state?: any): void;

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

        getPathLocation(): string;

        debug(buildMessage: Function): void;

        // ------------------------- ancestry -------------------------
        /**
         * Call the provided `callback` with the `NodePath`s of all the parents.
         * When the `callback` returns a truthy value, we return that node path.
         */
        findParent(callback: (path: NodePath<Node>) => boolean): NodePath<Node>;

        find(callback: (path: NodePath<Node>) => boolean): NodePath<Node>;

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

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

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

        /** Get the earliest path in the tree where the provided `paths` intersect. */
        getDeepestCommonAncestorFrom(paths: NodePath<Node>[], filter?: Function): NodePath<Node>;        

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

        inType(...candidateTypes: string[]): boolean;

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

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

        couldBeBaseType(name: string): boolean;

        baseTypeStrictlyMatches(right: NodePath<Node>): 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(nodes: Node[]): void;

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

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

        /**
         * This method takes an array of statements nodes and then explodes it
         * into expressions. This method retains completion records which is
         * extremely important to retain original semantics.
         */
        replaceExpressionWithStatements(nodes: Node[]): Node;

        replaceInline(nodes: Node | Node[]): void;

        // ------------------------- 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 };

        // ------------------------- 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;

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

        isBlacklisted(): boolean;

        visit(): boolean;

        skip(): void;

        skipKey(key: string): void;

        stop(): void;

        setScope(): void;

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

        popContext(): void;

        pushContext(context: TraversalContext): void;

        // ------------------------- removal -------------------------
        remove(): void;

        // ------------------------- modification -------------------------
        /** Insert the provided nodes before the current one. */
        insertBefore(nodes: Node | Node[]): any;

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

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

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

        // ------------------------- family -------------------------
        getStatementParent(): NodePath<Node>;

        getOpposite(): NodePath<Node>;

        getCompletionRecords(): NodePath<Node>[];

        getSibling(key: string): NodePath<Node>;

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

        getBindingIdentifiers(duplicates?: boolean): Node[];

        getOuterBindingIdentifiers(duplicates?: boolean): Node[];

        // ------------------------- 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;

        // ------------------------- isXXX -------------------------
        isArrayExpression(opts?: Object): boolean;
        isAssignmentExpression(opts?: Object): boolean;
        isBinaryExpression(opts?: Object): boolean;
        isDirective(opts?: Object): boolean;
        isDirectiveLiteral(opts?: Object): boolean;
        isBlockStatement(opts?: Object): boolean;
        isBreakStatement(opts?: Object): boolean;
        isCallExpression(opts?: Object): boolean;
        isCatchClause(opts?: Object): boolean;
        isConditionalExpression(opts?: Object): boolean;
        isContinueStatement(opts?: Object): boolean;
        isDebuggerStatement(opts?: Object): boolean;
        isDoWhileStatement(opts?: Object): boolean;
        isEmptyStatement(opts?: Object): boolean;
        isExpressionStatement(opts?: Object): boolean;
        isFile(opts?: Object): boolean;
        isForInStatement(opts?: Object): boolean;
        isForStatement(opts?: Object): boolean;
        isFunctionDeclaration(opts?: Object): boolean;
        isFunctionExpression(opts?: Object): boolean;
        isIdentifier(opts?: Object): boolean;
        isIfStatement(opts?: Object): boolean;
        isLabeledStatement(opts?: Object): boolean;
        isStringLiteral(opts?: Object): boolean;
        isNumericLiteral(opts?: Object): boolean;
        isNullLiteral(opts?: Object): boolean;
        isBooleanLiteral(opts?: Object): boolean;
        isRegExpLiteral(opts?: Object): boolean;
        isLogicalExpression(opts?: Object): boolean;
        isMemberExpression(opts?: Object): boolean;
        isNewExpression(opts?: Object): boolean;
        isProgram(opts?: Object): boolean;
        isObjectExpression(opts?: Object): boolean;
        isObjectMethod(opts?: Object): boolean;
        isObjectProperty(opts?: Object): boolean;
        isRestElement(opts?: Object): boolean;
        isReturnStatement(opts?: Object): boolean;
        isSequenceExpression(opts?: Object): boolean;
        isSwitchCase(opts?: Object): boolean;
        isSwitchStatement(opts?: Object): boolean;
        isThisExpression(opts?: Object): boolean;
        isThrowStatement(opts?: Object): boolean;
        isTryStatement(opts?: Object): boolean;
        isUnaryExpression(opts?: Object): boolean;
        isUpdateExpression(opts?: Object): boolean;
        isVariableDeclaration(opts?: Object): boolean;
        isVariableDeclarator(opts?: Object): boolean;
        isWhileStatement(opts?: Object): boolean;
        isWithStatement(opts?: Object): boolean;
        isAssignmentPattern(opts?: Object): boolean;
        isArrayPattern(opts?: Object): boolean;
        isArrowFunctionExpression(opts?: Object): boolean;
        isClassBody(opts?: Object): boolean;
        isClassDeclaration(opts?: Object): boolean;
        isClassExpression(opts?: Object): boolean;
        isExportAllDeclaration(opts?: Object): boolean;
        isExportDefaultDeclaration(opts?: Object): boolean;
        isExportNamedDeclaration(opts?: Object): boolean;
        isExportSpecifier(opts?: Object): boolean;
        isForOfStatement(opts?: Object): boolean;
        isImportDeclaration(opts?: Object): boolean;
        isImportDefaultSpecifier(opts?: Object): boolean;
        isImportNamespaceSpecifier(opts?: Object): boolean;
        isImportSpecifier(opts?: Object): boolean;
        isMetaProperty(opts?: Object): boolean;
        isClassMethod(opts?: Object): boolean;
        isObjectPattern(opts?: Object): boolean;
        isSpreadElement(opts?: Object): boolean;
        isSuper(opts?: Object): boolean;
        isTaggedTemplateExpression(opts?: Object): boolean;
        isTemplateElement(opts?: Object): boolean;
        isTemplateLiteral(opts?: Object): boolean;
        isYieldExpression(opts?: Object): boolean;
        isAnyTypeAnnotation(opts?: Object): boolean;
        isArrayTypeAnnotation(opts?: Object): boolean;
        isBooleanTypeAnnotation(opts?: Object): boolean;
        isBooleanLiteralTypeAnnotation(opts?: Object): boolean;
        isNullLiteralTypeAnnotation(opts?: Object): boolean;
        isClassImplements(opts?: Object): boolean;
        isClassProperty(opts?: Object): boolean;
        isDeclareClass(opts?: Object): boolean;
        isDeclareFunction(opts?: Object): boolean;
        isDeclareInterface(opts?: Object): boolean;
        isDeclareModule(opts?: Object): boolean;
        isDeclareTypeAlias(opts?: Object): boolean;
        isDeclareVariable(opts?: Object): boolean;
        isExistentialTypeParam(opts?: Object): boolean;
        isFunctionTypeAnnotation(opts?: Object): boolean;
        isFunctionTypeParam(opts?: Object): boolean;
        isGenericTypeAnnotation(opts?: Object): boolean;
        isInterfaceExtends(opts?: Object): boolean;
        isInterfaceDeclaration(opts?: Object): boolean;
        isIntersectionTypeAnnotation(opts?: Object): boolean;
        isMixedTypeAnnotation(opts?: Object): boolean;
        isNullableTypeAnnotation(opts?: Object): boolean;
        isNumericLiteralTypeAnnotation(opts?: Object): boolean;
        isNumberTypeAnnotation(opts?: Object): boolean;
        isStringLiteralTypeAnnotation(opts?: Object): boolean;
        isStringTypeAnnotation(opts?: Object): boolean;
        isThisTypeAnnotation(opts?: Object): boolean;
        isTupleTypeAnnotation(opts?: Object): boolean;
        isTypeofTypeAnnotation(opts?: Object): boolean;
        isTypeAlias(opts?: Object): boolean;
        isTypeAnnotation(opts?: Object): boolean;
        isTypeCastExpression(opts?: Object): boolean;
        isTypeParameterDeclaration(opts?: Object): boolean;
        isTypeParameterInstantiation(opts?: Object): boolean;
        isObjectTypeAnnotation(opts?: Object): boolean;
        isObjectTypeCallProperty(opts?: Object): boolean;
        isObjectTypeIndexer(opts?: Object): boolean;
        isObjectTypeProperty(opts?: Object): boolean;
        isQualifiedTypeIdentifier(opts?: Object): boolean;
        isUnionTypeAnnotation(opts?: Object): boolean;
        isVoidTypeAnnotation(opts?: Object): boolean;
        isJSXAttribute(opts?: Object): boolean;
        isJSXClosingElement(opts?: Object): boolean;
        isJSXElement(opts?: Object): boolean;
        isJSXEmptyExpression(opts?: Object): boolean;
        isJSXExpressionContainer(opts?: Object): boolean;
        isJSXIdentifier(opts?: Object): boolean;
        isJSXMemberExpression(opts?: Object): boolean;
        isJSXNamespacedName(opts?: Object): boolean;
        isJSXOpeningElement(opts?: Object): boolean;
        isJSXSpreadAttribute(opts?: Object): boolean;
        isJSXText(opts?: Object): boolean;
        isNoop(opts?: Object): boolean;
        isParenthesizedExpression(opts?: Object): boolean;
        isAwaitExpression(opts?: Object): boolean;
        isBindExpression(opts?: Object): boolean;
        isDecorator(opts?: Object): boolean;
        isDoExpression(opts?: Object): boolean;
        isExportDefaultSpecifier(opts?: Object): boolean;
        isExportNamespaceSpecifier(opts?: Object): boolean;
        isRestProperty(opts?: Object): boolean;
        isSpreadProperty(opts?: Object): boolean;
        isExpression(opts?: Object): boolean;
        isBinary(opts?: Object): boolean;
        isScopable(opts?: Object): boolean;
        isBlockParent(opts?: Object): boolean;
        isBlock(opts?: Object): boolean;
        isStatement(opts?: Object): boolean;
        isTerminatorless(opts?: Object): boolean;
        isCompletionStatement(opts?: Object): boolean;
        isConditional(opts?: Object): boolean;
        isLoop(opts?: Object): boolean;
        isWhile(opts?: Object): boolean;
        isExpressionWrapper(opts?: Object): boolean;
        isFor(opts?: Object): boolean;
        isForXStatement(opts?: Object): boolean;
        isFunction(opts?: Object): boolean;
        isFunctionParent(opts?: Object): boolean;
        isPureish(opts?: Object): boolean;
        isDeclaration(opts?: Object): boolean;
        isLVal(opts?: Object): boolean;
        isLiteral(opts?: Object): boolean;
        isImmutable(opts?: Object): boolean;
        isUserWhitespacable(opts?: Object): boolean;
        isMethod(opts?: Object): boolean;
        isObjectMember(opts?: Object): boolean;
        isProperty(opts?: Object): boolean;
        isUnaryLike(opts?: Object): boolean;
        isPattern(opts?: Object): boolean;
        isClass(opts?: Object): boolean;
        isModuleDeclaration(opts?: Object): boolean;
        isExportDeclaration(opts?: Object): boolean;
        isModuleSpecifier(opts?: Object): boolean;
        isFlow(opts?: Object): boolean;
        isFlowBaseAnnotation(opts?: Object): boolean;
        isFlowDeclaration(opts?: Object): boolean;
        isJSX(opts?: Object): boolean;
        isNumberLiteral(opts?: Object): boolean;
        isRegexLiteral(opts?: Object): boolean;
        isReferencedIdentifier(opts?: Object): boolean;
        isReferencedMemberExpression(opts?: Object): boolean;
        isBindingIdentifier(opts?: Object): boolean;
        isScope(opts?: Object): boolean;
        isReferenced(opts?: Object): boolean;
        isBlockScoped(opts?: Object): boolean;
        isVar(opts?: Object): boolean;
        isUser(opts?: Object): boolean;
        isGenerated(opts?: Object): boolean;
        isPure(opts?: Object): boolean;

        // ------------------------- assertXXX -------------------------
        assertArrayExpression(opts?: Object): void;
        assertAssignmentExpression(opts?: Object): void;
        assertBinaryExpression(opts?: Object): void;
        assertDirective(opts?: Object): void;
        assertDirectiveLiteral(opts?: Object): void;
        assertBlockStatement(opts?: Object): void;
        assertBreakStatement(opts?: Object): void;
        assertCallExpression(opts?: Object): void;
        assertCatchClause(opts?: Object): void;
        assertConditionalExpression(opts?: Object): void;
        assertContinueStatement(opts?: Object): void;
        assertDebuggerStatement(opts?: Object): void;
        assertDoWhileStatement(opts?: Object): void;
        assertEmptyStatement(opts?: Object): void;
        assertExpressionStatement(opts?: Object): void;
        assertFile(opts?: Object): void;
        assertForInStatement(opts?: Object): void;
        assertForStatement(opts?: Object): void;
        assertFunctionDeclaration(opts?: Object): void;
        assertFunctionExpression(opts?: Object): void;
        assertIdentifier(opts?: Object): void;
        assertIfStatement(opts?: Object): void;
        assertLabeledStatement(opts?: Object): void;
        assertStringLiteral(opts?: Object): void;
        assertNumericLiteral(opts?: Object): void;
        assertNullLiteral(opts?: Object): void;
        assertBooleanLiteral(opts?: Object): void;
        assertRegExpLiteral(opts?: Object): void;
        assertLogicalExpression(opts?: Object): void;
        assertMemberExpression(opts?: Object): void;
        assertNewExpression(opts?: Object): void;
        assertProgram(opts?: Object): void;
        assertObjectExpression(opts?: Object): void;
        assertObjectMethod(opts?: Object): void;
        assertObjectProperty(opts?: Object): void;
        assertRestElement(opts?: Object): void;
        assertReturnStatement(opts?: Object): void;
        assertSequenceExpression(opts?: Object): void;
        assertSwitchCase(opts?: Object): void;
        assertSwitchStatement(opts?: Object): void;
        assertThisExpression(opts?: Object): void;
        assertThrowStatement(opts?: Object): void;
        assertTryStatement(opts?: Object): void;
        assertUnaryExpression(opts?: Object): void;
        assertUpdateExpression(opts?: Object): void;
        assertVariableDeclaration(opts?: Object): void;
        assertVariableDeclarator(opts?: Object): void;
        assertWhileStatement(opts?: Object): void;
        assertWithStatement(opts?: Object): void;
        assertAssignmentPattern(opts?: Object): void;
        assertArrayPattern(opts?: Object): void;
        assertArrowFunctionExpression(opts?: Object): void;
        assertClassBody(opts?: Object): void;
        assertClassDeclaration(opts?: Object): void;
        assertClassExpression(opts?: Object): void;
        assertExportAllDeclaration(opts?: Object): void;
        assertExportDefaultDeclaration(opts?: Object): void;
        assertExportNamedDeclaration(opts?: Object): void;
        assertExportSpecifier(opts?: Object): void;
        assertForOfStatement(opts?: Object): void;
        assertImportDeclaration(opts?: Object): void;
        assertImportDefaultSpecifier(opts?: Object): void;
        assertImportNamespaceSpecifier(opts?: Object): void;
        assertImportSpecifier(opts?: Object): void;
        assertMetaProperty(opts?: Object): void;
        assertClassMethod(opts?: Object): void;
        assertObjectPattern(opts?: Object): void;
        assertSpreadElement(opts?: Object): void;
        assertSuper(opts?: Object): void;
        assertTaggedTemplateExpression(opts?: Object): void;
        assertTemplateElement(opts?: Object): void;
        assertTemplateLiteral(opts?: Object): void;
        assertYieldExpression(opts?: Object): void;
        assertAnyTypeAnnotation(opts?: Object): void;
        assertArrayTypeAnnotation(opts?: Object): void;
        assertBooleanTypeAnnotation(opts?: Object): void;
        assertBooleanLiteralTypeAnnotation(opts?: Object): void;
        assertNullLiteralTypeAnnotation(opts?: Object): void;
        assertClassImplements(opts?: Object): void;
        assertClassProperty(opts?: Object): void;
        assertDeclareClass(opts?: Object): void;
        assertDeclareFunction(opts?: Object): void;
        assertDeclareInterface(opts?: Object): void;
        assertDeclareModule(opts?: Object): void;
        assertDeclareTypeAlias(opts?: Object): void;
        assertDeclareVariable(opts?: Object): void;
        assertExistentialTypeParam(opts?: Object): void;
        assertFunctionTypeAnnotation(opts?: Object): void;
        assertFunctionTypeParam(opts?: Object): void;
        assertGenericTypeAnnotation(opts?: Object): void;
        assertInterfaceExtends(opts?: Object): void;
        assertInterfaceDeclaration(opts?: Object): void;
        assertIntersectionTypeAnnotation(opts?: Object): void;
        assertMixedTypeAnnotation(opts?: Object): void;
        assertNullableTypeAnnotation(opts?: Object): void;
        assertNumericLiteralTypeAnnotation(opts?: Object): void;
        assertNumberTypeAnnotation(opts?: Object): void;
        assertStringLiteralTypeAnnotation(opts?: Object): void;
        assertStringTypeAnnotation(opts?: Object): void;
        assertThisTypeAnnotation(opts?: Object): void;
        assertTupleTypeAnnotation(opts?: Object): void;
        assertTypeofTypeAnnotation(opts?: Object): void;
        assertTypeAlias(opts?: Object): void;
        assertTypeAnnotation(opts?: Object): void;
        assertTypeCastExpression(opts?: Object): void;
        assertTypeParameterDeclaration(opts?: Object): void;
        assertTypeParameterInstantiation(opts?: Object): void;
        assertObjectTypeAnnotation(opts?: Object): void;
        assertObjectTypeCallProperty(opts?: Object): void;
        assertObjectTypeIndexer(opts?: Object): void;
        assertObjectTypeProperty(opts?: Object): void;
        assertQualifiedTypeIdentifier(opts?: Object): void;
        assertUnionTypeAnnotation(opts?: Object): void;
        assertVoidTypeAnnotation(opts?: Object): void;
        assertJSXAttribute(opts?: Object): void;
        assertJSXClosingElement(opts?: Object): void;
        assertJSXElement(opts?: Object): void;
        assertJSXEmptyExpression(opts?: Object): void;
        assertJSXExpressionContainer(opts?: Object): void;
        assertJSXIdentifier(opts?: Object): void;
        assertJSXMemberExpression(opts?: Object): void;
        assertJSXNamespacedName(opts?: Object): void;
        assertJSXOpeningElement(opts?: Object): void;
        assertJSXSpreadAttribute(opts?: Object): void;
        assertJSXText(opts?: Object): void;
        assertNoop(opts?: Object): void;
        assertParenthesizedExpression(opts?: Object): void;
        assertAwaitExpression(opts?: Object): void;
        assertBindExpression(opts?: Object): void;
        assertDecorator(opts?: Object): void;
        assertDoExpression(opts?: Object): void;
        assertExportDefaultSpecifier(opts?: Object): void;
        assertExportNamespaceSpecifier(opts?: Object): void;
        assertRestProperty(opts?: Object): void;
        assertSpreadProperty(opts?: Object): void;
        assertExpression(opts?: Object): void;
        assertBinary(opts?: Object): void;
        assertScopable(opts?: Object): void;
        assertBlockParent(opts?: Object): void;
        assertBlock(opts?: Object): void;
        assertStatement(opts?: Object): void;
        assertTerminatorless(opts?: Object): void;
        assertCompletionStatement(opts?: Object): void;
        assertConditional(opts?: Object): void;
        assertLoop(opts?: Object): void;
        assertWhile(opts?: Object): void;
        assertExpressionWrapper(opts?: Object): void;
        assertFor(opts?: Object): void;
        assertForXStatement(opts?: Object): void;
        assertFunction(opts?: Object): void;
        assertFunctionParent(opts?: Object): void;
        assertPureish(opts?: Object): void;
        assertDeclaration(opts?: Object): void;
        assertLVal(opts?: Object): void;
        assertLiteral(opts?: Object): void;
        assertImmutable(opts?: Object): void;
        assertUserWhitespacable(opts?: Object): void;
        assertMethod(opts?: Object): void;
        assertObjectMember(opts?: Object): void;
        assertProperty(opts?: Object): void;
        assertUnaryLike(opts?: Object): void;
        assertPattern(opts?: Object): void;
        assertClass(opts?: Object): void;
        assertModuleDeclaration(opts?: Object): void;
        assertExportDeclaration(opts?: Object): void;
        assertModuleSpecifier(opts?: Object): void;
        assertFlow(opts?: Object): void;
        assertFlowBaseAnnotation(opts?: Object): void;
        assertFlowDeclaration(opts?: Object): void;
        assertJSX(opts?: Object): void;
        assertNumberLiteral(opts?: Object): void;
        assertRegexLiteral(opts?: Object): void;
    }

    export class Hub {
        constructor(file: any, options: any);
        file: any;
        options: any;
    }

    interface TraversalContext {
        parentPath: NodePath<Node>;
        scope: Scope;
        state: any;
        opts: any;
    }
}