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

declare module "babel-types" {

    export interface Comment {
        value: string;
        start: number;
        end: number;
        loc: SourceLocation;
    }

    export interface CommentBlock extends Comment {
        type: "CommentBlock";
    }

    export interface CommentLine extends Comment {
        type: "CommentLine";
    }

    export interface SourceLocation {
        start: {
            line: number;
            column: number;
        };

        end: {
            line: number;
            column: number;
        };
    }

    export interface Node {
        type: string;
        leadingComments?: Array<Comment>;
        innerComments?: Array<Comment>;
        trailingComments?: Array<Comment>;
        start: number;
        end: number;
        loc: SourceLocation;
    }

    export interface ArrayExpression extends Node {
        type: "ArrayExpression";
        elements: Array<Expression | SpreadElement>;
    }

    export interface AssignmentExpression extends Node {
        type: "AssignmentExpression";
        operator: "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "<<=" | ">>=" | ">>>=" | "|=" | "^=" | "&=";
        left: LVal;
        right: Expression;
    }

    export interface BinaryExpression extends Node {
        type: "BinaryExpression";
        operator: "+" | "-" | "/" | "%" | "*" | "**" | "&" | "|" | ">>" | ">>>" | "<<" | "^" | "==" | "===" | "!=" | "!==" | "in" | "instanceof" | ">" | "<" | ">=" | "<=";
        left: Expression;
        right: Expression;
    }

    export interface Directive extends Node {
        type: "Directive";
        value: DirectiveLiteral;
    }

    export interface DirectiveLiteral extends Node {
        type: "DirectiveLiteral";
        value: string;
    }

    export interface BlockStatement extends Node {
        type: "BlockStatement";
        directives?: Directive[];
        body: Statement[];
    }

    export interface BreakStatement extends Node {
        type: "BreakStatement";
        label: Identifier;
    }

    export interface CallExpression extends Node {
        type: "CallExpression";
        callee: Expression | Super;
        arguments: Array<Expression | SpreadElement>;
    }

    export interface CatchClause extends Node {
        type: "CatchClause";
        param: Pattern;
        body: BlockStatement;
    }

    export interface ConditionalExpression extends Node {
        type: "ConditionalExpression";
        test: Expression;
        consequent: Expression;
        alternate: Expression;
    }

    export interface ContinueStatement extends Node {
        type: "ContinueStatement";
        label: Identifier;
    }

    export interface DebuggerStatement extends Node {
        type: "DebuggerStatement";
    }

    export interface DoWhileStatement extends Node {
        type: "DoWhileStatement";
        test: Expression;
        body: Statement;
    }

    export interface EmptyStatement extends Node {
        type: "EmptyStatement";
    }

    export interface ExpressionStatement extends Node {
        type: "ExpressionStatement";
        expression: Expression;
    }

    export interface File extends Node {
        type: "File";
        program: Program;
        comments: Comment[];
        tokens: any[];
    }

    export interface ForInStatement extends Node {
        type: "ForInStatement";
        left: VariableDeclaration | LVal;
        right: Expression;
        body: Statement;
    }

    export interface ForStatement extends Node {
        type: "ForStatement";
        init: VariableDeclaration | Expression;
        test: Expression;
        update: Expression;
        body: Statement;
    }

    export interface FunctionDeclaration extends Node {
        type: "FunctionDeclaration";
        id: Identifier;
        params: Pattern[];
        body: BlockStatement;
        generator: boolean;
        async: boolean;
        returnType?: TypeAnnotation;
        typeParameters?: TypeParameterDeclaration;
    }

    export interface FunctionExpression extends Node {
        type: "FunctionExpression";
        id: Identifier;
        params: Pattern[];
        body: BlockStatement;
        generator: boolean;
        async: boolean;
        returnType?: TypeAnnotation;
        typeParameters?: TypeParameterDeclaration;
    }

    export interface Identifier extends Node {
        type: "Identifier";
        name: string;
        typeAnnotation?: TypeAnnotation;
    }

    export interface IfStatement extends Node {
        type: "IfStatement";
        test: Expression;
        consequent: Statement;
        alternate: Statement;
    }

    export interface LabeledStatement extends Node {
        type: "LabeledStatement";
        label: Identifier;
        body: Statement;
    }

    export interface StringLiteral extends Node {
        type: "StringLiteral";
        value: string;
    }

    export interface NumericLiteral extends Node {
        type: "NumericLiteral";
        value: number;
    }

    export interface NullLiteral extends Node {
        type: "NullLiteral";
    }

    export interface BooleanLiteral extends Node {
        type: "BooleanLiteral";
        value: boolean;
    }

    export interface RegExpLiteral extends Node {
        type: "RegExpLiteral";
        pattern: string;
        flags?: string;
    }

    export interface LogicalExpression extends Node {
        type: "LogicalExpression";
        operator: "||" | "&&";
        left: Expression;
        right: Expression;
    }

    export interface MemberExpression extends Node {
        type: "MemberExpression";
        object: Expression | Super;
        property: Expression;
        computed: boolean;
    }

    export interface NewExpression extends Node {
        type: "NewExpression";
        callee: Expression | Super;
        arguments: Array<Expression | SpreadElement>;
    }

    export interface Program extends Node {
        type: "Program";
        sourceType: "script" | "module";
        directives?: Directive[];
        body: Array<Statement | ModuleDeclaration>;
    }

    export interface ObjectExpression extends Node {
        type: "ObjectExpression";
        properties: Array<ObjectProperty | ObjectMethod | SpreadProperty>;
    }

    export interface ObjectMethod extends Node {
        type: "ObjectMethod";
        key: Expression;
        kind: "get" | "set" | "method";
        shorthand: boolean;
        computed: boolean;
        value: Expression;
        decorators?: Decorator[];
        id: Identifier;
        params: Pattern[];
        body: BlockStatement;
        generator: boolean;
        async: boolean;
        returnType?: TypeAnnotation;
        typeParameters?: TypeParameterDeclaration;
    }

    export interface ObjectProperty extends Node {
        type: "ObjectProperty";
        key: Expression;
        computed: boolean;
        value: Expression;
        decorators?: Decorator[];
        shorthand: boolean;
    }

    export interface RestElement extends Node {
        type: "RestElement";
        argument: LVal;
        typeAnnotation?: TypeAnnotation;
    }

    export interface ReturnStatement extends Node {
        type: "ReturnStatement";
        argument: Expression;
    }

    export interface SequenceExpression extends Node {
        type: "SequenceExpression";
        expressions: Expression[];
    }

    export interface SwitchCase extends Node {
        type: "SwitchCase";
        test: Expression;
        consequent: Statement[];
    }

    export interface SwitchStatement extends Node {
        type: "SwitchStatement";
        discriminant: Expression;
        cases: SwitchCase[];
    }

    export interface ThisExpression extends Node {
        type: "ThisExpression";
    }

    export interface ThrowStatement extends Node {
        type: "ThrowStatement";
        argument: Expression;
    }

    export interface TryStatement extends Node {
        type: "TryStatement";
        block: BlockStatement;
        handler: CatchClause;
        finalizer: BlockStatement;
    }

    export interface UnaryExpression extends Node {
        type: "UnaryExpression";
        operator: "-" | "+" | "!" | "~" | "typeof" | "void" | "delete";
        prefix: boolean;
        argument: Expression;
    }

    export interface UpdateExpression extends Node {
        type: "UpdateExpression";
        operator: "++" | "--";
        prefix: boolean;
        argument: Expression;
    }

    export interface VariableDeclaration extends Node {
        type: "VariableDeclaration";
        declarations: VariableDeclarator[];
        kind: "var" | "let" | "const";
    }

    export interface VariableDeclarator extends Node {
        type: "VariableDeclarator";
        id: LVal;
        init: Expression;
    }

    export interface WhileStatement extends Node {
        type: "WhileStatement";
        test: Expression;
        body: Statement;
    }

    export interface WithStatement extends Node {
        type: "WithStatement";
        object: Expression;
        body: BlockStatement | Statement;
    }

    export interface AssignmentPattern extends Node {
        type: "AssignmentPattern";
        left: Pattern;
        right: Expression;
    }

    export interface ArrayPattern extends Node {
        type: "ArrayPattern";
        elements: Array<Pattern>;
        typeAnnotation?: TypeAnnotation;
    }

    export interface ArrowFunctionExpression extends Node {
        type: "ArrowFunctionExpression";
        id: Identifier;
        params: Pattern[];
        body: BlockStatement | Expression;
        generator: boolean;
        async: boolean;
        expression: boolean;
        returnType?: TypeAnnotation;
        typeParameters?: TypeParameterDeclaration;
    }

    export interface ClassBody extends Node {
        type: "ClassBody";
        body: Array<ClassMethod | ClassProperty>;
    }

    export interface ClassDeclaration extends Node {
        type: "ClassDeclaration";
        id: Identifier;
        superClass: Expression;
        body: ClassBody;
        decorators?: Decorator[];
        implements?: ClassImplements[];
        mixins?: any[];
        typeParameters?: TypeParameterDeclaration;
        superTypeParameters?: TypeParameterInstantiation;
    }

    export interface ClassExpression extends Node {
        type: "ClassExpression";
        id: Identifier;
        superClass: Expression;
        body: ClassBody;
        decorators?: Decorator[];
        implements?: ClassImplements[];
        mixins?: any[];
        typeParameters?: TypeParameterDeclaration;
        superTypeParameters?: TypeParameterInstantiation;
    }

    export interface ExportAllDeclaration extends Node {
        type: "ExportAllDeclaration";
        source: StringLiteral;
    }

    export interface ExportDefaultDeclaration extends Node {
        type: "ExportDefaultDeclaration";
        declaration: Declaration | Expression;
    }

    export interface ExportNamedDeclaration extends Node {
        type: "ExportNamedDeclaration";
        declaration: Declaration;
        specifiers: ExportSpecifier[];
        source: StringLiteral;
    }

    export interface ExportSpecifier extends Node {
        type: "ExportSpecifier";
        local: Identifier;
        imported: Identifier;
        exported: Identifier;
    }

    export interface ForOfStatement extends Node {
        type: "ForOfStatement";
        left: VariableDeclaration | LVal;
        right: Expression;
        body: Statement;
    }

    export interface ImportDeclaration extends Node {
        type: "ImportDeclaration";
        specifiers: Array<ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier>;
        source: StringLiteral;
    }

    export interface ImportDefaultSpecifier extends Node {
        type: "ImportDefaultSpecifier";
        local: Identifier;
    }

    export interface ImportNamespaceSpecifier extends Node {
        type: "ImportNamespaceSpecifier";
        local: Identifier;
    }

    export interface ImportSpecifier extends Node {
        type: "ImportSpecifier";
        local: Identifier;
        imported: Identifier;
    }

    export interface MetaProperty extends Node {
        type: "MetaProperty";
        meta: Identifier;
        property: Identifier;
    }

    export interface ClassMethod extends Node {
        type: "ClassMethod";
        key: Expression;
        value?: FunctionExpression;
        kind: "constructor" | "method" | "get" | "set";
        computed: boolean;
        static: boolean;
        decorators?: Decorator[];
        id: Identifier;
        params: Pattern[];
        body: BlockStatement;
        generator: boolean;
        async: boolean;
        expression: boolean;
        returnType?: TypeAnnotation;
        typeParameters?: TypeParameterDeclaration;
    }

    // See: https://github.com/babel/babel/blob/master/doc/ast/spec.md#objectpattern
    export interface AssignmentProperty extends Node {
        type: "ObjectProperty";
        key: Expression;
        computed: boolean;
        value: Pattern;
        decorators?: Decorator[];
        shorthand: boolean;
    }

    export interface ObjectPattern extends Node {
        type: "ObjectPattern";
        properties: Array<AssignmentProperty | RestProperty>;
        typeAnnotation?: TypeAnnotation;
    }

    export interface SpreadElement extends Node {
        type: "SpreadElement";
        argument: Expression;
    }

    export interface Super extends Node {
        type: "Super";
    }

    export interface TaggedTemplateExpression extends Node {
        type: "TaggedTemplateExpression";
        tag: Expression;
        quasi: TemplateLiteral;
    }

    export interface TemplateElement extends Node {
        type: "TemplateElement";
        tail: boolean;
        value: {
            cooked: string;
            raw: string;
        };
    }

    export interface TemplateLiteral extends Node {
        type: "TemplateLiteral";
        quasis: TemplateElement[];
        expressions: Expression[];
    }

    export interface YieldExpression extends Node {
        type: "YieldExpression";
        argument: Expression;
        delegate: boolean;
    }

    export interface AnyTypeAnnotation extends Node {
        type: "AnyTypeAnnotation";
    }

    export interface ArrayTypeAnnotation extends Node {
        type: "ArrayTypeAnnotation";
        elementType: FlowTypeAnnotation;
    }

    export interface BooleanTypeAnnotation extends Node {
        type: "BooleanTypeAnnotation";
    }

    export interface BooleanLiteralTypeAnnotation extends Node {
        type: "BooleanLiteralTypeAnnotation";
    }

    export interface NullLiteralTypeAnnotation extends Node {
        type: "NullLiteralTypeAnnotation";
    }

    export interface ClassImplements extends Node {
        type: "ClassImplements";
        id: Identifier;
        typeParameters: TypeParameterInstantiation;
    }

    export interface ClassProperty extends Node {
        type: "ClassProperty";
        key: Identifier;
        value: Expression;
        decorators?: Decorator[];
        typeAnnotation?: TypeAnnotation;
    }

    export interface DeclareClass extends Node {
        type: "DeclareClass";
        id: Identifier;
        typeParameters: TypeParameterDeclaration;
        extends: InterfaceExtends[];
        body: ObjectTypeAnnotation;
    }

    export interface DeclareFunction extends Node {
        type: "DeclareFunction";
        id: Identifier;
    }

    export interface DeclareInterface extends Node {
        type: "DeclareInterface";
        id: Identifier;
        typeParameters: TypeParameterDeclaration;
        extends: InterfaceExtends[];
        body: ObjectTypeAnnotation;
    }

    export interface DeclareModule extends Node {
        type: "DeclareModule";
        id: StringLiteral | Identifier;
        body: BlockStatement;
    }

    export interface DeclareTypeAlias extends Node {
        type: "DeclareTypeAlias";
        id: Identifier;
        typeParameters: TypeParameterDeclaration;
        right: FlowTypeAnnotation;
    }

    export interface DeclareVariable extends Node {
        type: "DeclareVariable";
        id: Identifier;
    }

    export interface ExistentialTypeParam extends Node {
        type: "ExistentialTypeParam";
    }

    export interface FunctionTypeAnnotation extends Node {
        type: "FunctionTypeAnnotation";
        typeParameters: TypeParameterDeclaration;
        params: FunctionTypeParam[];
        rest: FunctionTypeParam;
        returnType: FlowTypeAnnotation;
    }

    export interface FunctionTypeParam extends Node {
        type: "FunctionTypeParam";
        name: Identifier;
        typeAnnotation: FlowTypeAnnotation;
    }

    export interface GenericTypeAnnotation extends Node {
        type: "GenericTypeAnnotation";
        id: Identifier;
        typeParameters: TypeParameterInstantiation;
    }

    export interface InterfaceExtends extends Node {
        type: "InterfaceExtends";
        id: Identifier;
        typeParameters: TypeParameterInstantiation;
    }

    export interface InterfaceDeclaration extends Node {
        type: "InterfaceDeclaration";
        id: Identifier;
        typeParameters: TypeParameterDeclaration;
        extends: InterfaceExtends[];
        mixins?: any[];
        body: ObjectTypeAnnotation;
    }

    export interface IntersectionTypeAnnotation extends Node {
        type: "IntersectionTypeAnnotation";
        types: FlowTypeAnnotation[];
    }

    export interface MixedTypeAnnotation extends Node {
        type: "MixedTypeAnnotation";
    }

    export interface NullableTypeAnnotation extends Node {
        type: "NullableTypeAnnotation";
        typeAnnotation: FlowTypeAnnotation;
    }

    export interface NumericLiteralTypeAnnotation extends Node {
        type: "NumericLiteralTypeAnnotation";
    }

    export interface NumberTypeAnnotation extends Node {
        type: "NumberTypeAnnotation";
    }

    export interface StringLiteralTypeAnnotation extends Node {
        type: "StringLiteralTypeAnnotation";
    }

    export interface StringTypeAnnotation extends Node {
        type: "StringTypeAnnotation";
    }

    export interface ThisTypeAnnotation extends Node {
        type: "ThisTypeAnnotation";
    }

    export interface TupleTypeAnnotation extends Node {
        type: "TupleTypeAnnotation";
        types: FlowTypeAnnotation[];
    }

    export interface TypeofTypeAnnotation extends Node {
        type: "TypeofTypeAnnotation";
        argument: FlowTypeAnnotation;
    }

    export interface TypeAlias extends Node {
        type: "TypeAlias";
        id: Identifier;
        typeParameters: TypeParameterDeclaration;
        right: FlowTypeAnnotation;
    }

    export interface TypeAnnotation extends Node {
        type: "TypeAnnotation";
        typeAnnotation: FlowTypeAnnotation;
    }

    export interface TypeCastExpression extends Node {
        type: "TypeCastExpression";
        expression: Expression;
        typeAnnotation: FlowTypeAnnotation;
    }

    export interface TypeParameterDeclaration extends Node {
        type: "TypeParameterDeclaration";
        params: Identifier[];
    }

    export interface TypeParameterInstantiation extends Node {
        type: "TypeParameterInstantiation";
        params: FlowTypeAnnotation[];
    }

    export interface ObjectTypeAnnotation extends Node {
        type: "ObjectTypeAnnotation";
        properties: ObjectTypeProperty[];
        indexers: ObjectTypeIndexer[];
        callProperties: ObjectTypeCallProperty[];
    }

    export interface ObjectTypeCallProperty extends Node {
        type: "ObjectTypeCallProperty";
        value: FlowTypeAnnotation;
    }

    export interface ObjectTypeIndexer extends Node {
        type: "ObjectTypeIndexer";
        id: Expression;
        key: FlowTypeAnnotation;
        value: FlowTypeAnnotation;
    }

    export interface ObjectTypeProperty extends Node {
        type: "ObjectTypeProperty";
        key: Expression;
        value: FlowTypeAnnotation;
    }

    export interface QualifiedTypeIdentifier extends Node {
        type: "QualifiedTypeIdentifier";
        id: Identifier;
        qualification: Identifier | QualifiedTypeIdentifier;
    }

    export interface UnionTypeAnnotation extends Node {
        type: "UnionTypeAnnotation";
        types: FlowTypeAnnotation[];
    }

    export interface VoidTypeAnnotation extends Node {
        type: "VoidTypeAnnotation";
    }

    export interface JSXAttribute extends Node {
        type: "JSXAttribute";
        name: JSXIdentifier | JSXNamespacedName;
        value: JSXElement | StringLiteral | JSXExpressionContainer;
    }

    export interface JSXClosingElement extends Node {
        type: "JSXClosingElement";
        name: JSXIdentifier | JSXMemberExpression;
    }

    export interface JSXElement extends Node {
        type: "JSXElement";
        openingElement: JSXOpeningElement;
        closingElement: JSXClosingElement;
        children: Array<JSXElement | JSXExpressionContainer | JSXText>;
        selfClosing?: boolean;
    }

    export interface JSXEmptyExpression extends Node {
        type: "JSXEmptyExpression";
    }

    export interface JSXExpressionContainer extends Node {
        type: "JSXExpressionContainer";
        expression: Expression;
    }

    export interface JSXIdentifier extends Node {
        type: "JSXIdentifier";
        name: string;
    }

    export interface JSXMemberExpression extends Node {
        type: "JSXMemberExpression";
        object: JSXMemberExpression | JSXIdentifier;
        property: JSXIdentifier;
    }

    export interface JSXNamespacedName extends Node {
        type: "JSXNamespacedName";
        namespace: JSXIdentifier;
        name: JSXIdentifier;
    }

    export interface JSXOpeningElement extends Node {
        type: "JSXOpeningElement";
        name: JSXIdentifier | JSXMemberExpression;
        selfClosing: boolean;
        attributes: JSXAttribute[];
    }

    export interface JSXSpreadAttribute extends Node {
        type: "JSXSpreadAttribute";
        argument: Expression;
    }

    export interface JSXText extends Node {
        type: "JSXText";
        value: string;
    }

    export interface Noop extends Node {
        type: "Noop";
    }

    export interface ParenthesizedExpression extends Node {
        type: "ParenthesizedExpression";
        expression: Expression;
    }

    export interface AwaitExpression extends Node {
        type: "AwaitExpression";
        argument: Expression;
    }

    export interface BindExpression extends Node {
        type: "BindExpression";
        object: Expression;
        callee: Expression;
    }

    export interface Decorator extends Node {
        type: "Decorator";
        expression: Expression;
    }

    export interface DoExpression extends Node {
        type: "DoExpression";
        body: BlockStatement;
    }

    export interface ExportDefaultSpecifier extends Node {
        type: "ExportDefaultSpecifier";
        exported: Identifier;
    }

    export interface ExportNamespaceSpecifier extends Node {
        type: "ExportNamespaceSpecifier";
        exported: Identifier;
    }

    export interface RestProperty extends Node {
        type: "RestProperty";
        argument: LVal;
    }

    export interface SpreadProperty extends Node {
        type: "SpreadProperty";
        argument: Expression;
    }

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

    export function arrayExpression(elements?: Array<Expression | SpreadElement>): ArrayExpression;
    export function assignmentExpression(operator?: string, left?: LVal, right?: Expression): AssignmentExpression;
    export function binaryExpression(operator?: "+" | "-" | "/" | "%" | "*" | "**" | "&" | "|" | ">>" | ">>>" | "<<" | "^" | "==" | "===" | "!=" | "!==" | "in" | "instanceof" | ">" | "<" | ">=" | "<=", left?: Expression, right?: Expression): BinaryExpression;
    export function directive(value?: DirectiveLiteral): Directive;
    export function directiveLiteral(value?: string): DirectiveLiteral;
    export function blockStatement(body?: Statement[], directives?: Directive[]): BlockStatement;
    export function breakStatement(label?: Identifier): BreakStatement;
    export function callExpression(callee?: Expression, _arguments?: Array<Expression | SpreadElement>): CallExpression;
    export function catchClause(param?: Identifier, body?: BlockStatement): CatchClause;
    export function conditionalExpression(test?: Expression, consequent?: Expression, alternate?: Expression): ConditionalExpression;
    export function continueStatement(label?: Identifier): ContinueStatement;
    export function debuggerStatement(): DebuggerStatement;
    export function doWhileStatement(test?: Expression, body?: Statement): DoWhileStatement;
    export function emptyStatement(): EmptyStatement;
    export function expressionStatement(expression?: Expression): ExpressionStatement;
    export function file(program?: Program, comments?: Comment[], tokens?: any[]): File;
    export function forInStatement(left?: VariableDeclaration | LVal, right?: Expression, body?: Statement): ForInStatement;
    export function forStatement(init?: VariableDeclaration | Expression, test?: Expression, update?: Expression, body?: Statement): ForStatement;
    export function functionDeclaration(id?: Identifier, params?: Pattern[], body?: BlockStatement, generator?: boolean, async?: boolean): FunctionDeclaration;
    export function functionExpression(id?: Identifier, params?: Pattern[], body?: BlockStatement, generator?: boolean, async?: boolean): FunctionExpression;
    export function identifier(name?: string): Identifier;
    export function ifStatement(test?: Expression, consequent?: Statement, alternate?: Statement): IfStatement;
    export function labeledStatement(label?: Identifier, body?: Statement): LabeledStatement;
    export function stringLiteral(value?: string): StringLiteral;
    export function numericLiteral(value?: number): NumericLiteral;
    export function nullLiteral(): NullLiteral;
    export function booleanLiteral(value?: boolean): BooleanLiteral;
    export function regExpLiteral(pattern?: string, flags?: string): RegExpLiteral;
    export function logicalExpression(operator?: "||" | "&&", left?: Expression, right?: Expression): LogicalExpression;
    export function memberExpression(object?: Expression | Super, property?: Expression, computed?: boolean): MemberExpression;
    export function newExpression(callee?: Expression | Super, _arguments?: Array<Expression | SpreadElement>): NewExpression;
    export function program(body?: Array<Statement | ModuleDeclaration>, directives?: Directive[]): Program;
    export function objectExpression(properties?: Array<ObjectProperty | ObjectMethod | SpreadProperty>): ObjectExpression;
    export function objectMethod(kind?: "get" | "set" | "method", key?: Expression, params?: Pattern[], body?: BlockStatement, computed?: boolean): ObjectMethod;
    export function objectProperty(key?: Expression, value?: Expression, computed?: boolean, shorthand?: boolean, decorators?: Decorator[]): ObjectProperty;
    export function restElement(argument?: LVal, typeAnnotation?: TypeAnnotation): RestElement;
    export function returnStatement(argument?: Expression): ReturnStatement;
    export function sequenceExpression(expressions?: Expression[]): SequenceExpression;
    export function switchCase(test?: Expression, consequent?: Statement[]): SwitchCase;
    export function switchStatement(discriminant?: Expression, cases?: SwitchCase[]): SwitchStatement;
    export function thisExpression(): ThisExpression;
    export function throwStatement(argument?: Expression): ThrowStatement;
    export function tryStatement(block?: BlockStatement, handler?: CatchClause, finalizer?: BlockStatement): TryStatement;
    export function unaryExpression(operator?: "void" | "delete" | "!" | "+" | "-" | "++" | "--" | "~" | "typeof", argument?: Expression, prefix?: boolean): UnaryExpression;
    export function updateExpression(operator?: "++" | "--", argument?: Expression, prefix?: boolean): UpdateExpression;
    export function variableDeclaration(kind?: "var" | "let" | "const", declarations?: VariableDeclarator[]): VariableDeclaration;
    export function variableDeclarator(id?: LVal, init?: Expression): VariableDeclarator;
    export function whileStatement(test?: Expression, body?: BlockStatement | Statement): WhileStatement;
    export function withStatement(object?: Expression, body?: BlockStatement | Statement): WithStatement;
    export function assignmentPattern(left?: Identifier, right?: Expression): AssignmentPattern;
    export function arrayPattern(elements?: Array<Pattern>, typeAnnotation?: TypeAnnotation): ArrayPattern;
    export function arrowFunctionExpression(params?: Pattern[], body?: BlockStatement | Expression, async?: boolean): ArrowFunctionExpression;
    export function classBody(body?: Array<ClassMethod | ClassProperty>): ClassBody;
    export function classDeclaration(id?: Identifier, superClass?: Expression, body?: ClassBody, decorators?: Decorator[]): ClassDeclaration;
    export function classExpression(id?: Identifier, superClass?: Expression, body?: ClassBody, decorators?: Decorator[]): ClassExpression;
    export function exportAllDeclaration(source?: StringLiteral): ExportAllDeclaration;
    export function exportDefaultDeclaration(declaration?: FunctionDeclaration | ClassDeclaration | Expression): ExportDefaultDeclaration;
    export function exportNamedDeclaration(declaration?: Declaration, specifiers?: ExportSpecifier[], source?: StringLiteral): ExportNamedDeclaration;
    export function exportSpecifier(local?: Identifier, exported?: Identifier): ExportSpecifier;
    export function forOfStatement(left?: VariableDeclaration | LVal, right?: Expression, body?: Statement): ForOfStatement;
    export function importDeclaration(specifiers?: Array<ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier>, source?: StringLiteral): ImportDeclaration;
    export function importDefaultSpecifier(local?: Identifier): ImportDefaultSpecifier;
    export function importNamespaceSpecifier(local?: Identifier): ImportNamespaceSpecifier;
    export function importSpecifier(local?: Identifier, imported?: Identifier): ImportSpecifier;
    export function metaProperty(meta?: string, property?: string): MetaProperty;
    export function classMethod(kind?: "constructor" | "method" | "get" | "set", key?: Expression, params?: Pattern[], body?: BlockStatement, computed?: boolean, _static?: boolean): ClassMethod;
    export function objectPattern(properties?: Array<AssignmentProperty | RestProperty>, typeAnnotation?: TypeAnnotation): ObjectPattern;
    export function spreadElement(argument?: Expression): SpreadElement;
    export function taggedTemplateExpression(tag?: Expression, quasi?: TemplateLiteral): TaggedTemplateExpression;
    export function templateElement(value?: {cooked?: string; raw?: string;}, tail?: boolean): TemplateElement;
    export function templateLiteral(quasis?: TemplateElement[], expressions?: Expression[]): TemplateLiteral;
    export function yieldExpression(argument?: Expression, delegate?: boolean): YieldExpression;
    export function anyTypeAnnotation(): AnyTypeAnnotation;
    export function arrayTypeAnnotation(elementType?: FlowTypeAnnotation): ArrayTypeAnnotation;
    export function booleanTypeAnnotation(): BooleanTypeAnnotation;
    export function booleanLiteralTypeAnnotation(): BooleanLiteralTypeAnnotation;
    export function nullLiteralTypeAnnotation(): NullLiteralTypeAnnotation;
    export function classImplements(id?: Identifier, typeParameters?: TypeParameterInstantiation): ClassImplements;
    export function classProperty(key?: Identifier, value?: Expression, typeAnnotation?: TypeAnnotation, decorators?: Decorator[]): ClassProperty;
    export function declareClass(id?: Identifier, typeParameters?: TypeParameterDeclaration, _extends?: InterfaceExtends[], body?: ObjectTypeAnnotation): DeclareClass;
    export function declareFunction(id?: Identifier): DeclareFunction;
    export function declareInterface(id?: Identifier, typeParameters?: TypeParameterDeclaration, _extends?: InterfaceExtends[], body?: ObjectTypeAnnotation): DeclareInterface;
    export function declareModule(id?: StringLiteral | Identifier, body?: BlockStatement): DeclareModule;
    export function declareTypeAlias(id?: Identifier, typeParameters?: TypeParameterDeclaration, right?: FlowTypeAnnotation): DeclareTypeAlias;
    export function declareVariable(id?: Identifier): DeclareVariable;
    export function existentialTypeParam(): ExistentialTypeParam;
    export function functionTypeAnnotation(typeParameters?: TypeParameterDeclaration, params?: FunctionTypeParam[], rest?: FunctionTypeParam, returnType?: FlowTypeAnnotation): FunctionTypeAnnotation;
    export function functionTypeParam(name?: Identifier, typeAnnotation?: FlowTypeAnnotation): FunctionTypeParam;
    export function genericTypeAnnotation(id?: Identifier, typeParameters?: TypeParameterInstantiation): GenericTypeAnnotation;
    export function interfaceExtends(id?: Identifier, typeParameters?: TypeParameterInstantiation): InterfaceExtends;
    export function interfaceDeclaration(id?: Identifier, typeParameters?: TypeParameterDeclaration, _extends?: InterfaceExtends[], body?: ObjectTypeAnnotation): InterfaceDeclaration;
    export function intersectionTypeAnnotation(types?: FlowTypeAnnotation[]): IntersectionTypeAnnotation;
    export function mixedTypeAnnotation(): MixedTypeAnnotation;
    export function nullableTypeAnnotation(typeAnnotation?: FlowTypeAnnotation): NullableTypeAnnotation;
    export function numericLiteralTypeAnnotation(): NumericLiteralTypeAnnotation;
    export function numberTypeAnnotation(): NumberTypeAnnotation;
    export function stringLiteralTypeAnnotation(): StringLiteralTypeAnnotation;
    export function stringTypeAnnotation(): StringTypeAnnotation;
    export function thisTypeAnnotation(): ThisTypeAnnotation;
    export function tupleTypeAnnotation(types?: FlowTypeAnnotation[]): TupleTypeAnnotation;
    export function typeofTypeAnnotation(argument?: FlowTypeAnnotation): TypeofTypeAnnotation;
    export function typeAlias(id?: Identifier, typeParameters?: TypeParameterDeclaration, right?: FlowTypeAnnotation): TypeAlias;
    export function typeAnnotation(typeAnnotation?: FlowTypeAnnotation): TypeAnnotation;
    export function typeCastExpression(expression?: Expression, typeAnnotation?: FlowTypeAnnotation): TypeCastExpression;
    export function typeParameterDeclaration(params?: Identifier[]): TypeParameterDeclaration;
    export function typeParameterInstantiation(params?: FlowTypeAnnotation[]): TypeParameterInstantiation;
    export function objectTypeAnnotation(properties?: ObjectTypeProperty[], indexers?: ObjectTypeIndexer[], callProperties?: ObjectTypeCallProperty[]): ObjectTypeAnnotation;
    export function objectTypeCallProperty(value?: FlowTypeAnnotation): ObjectTypeCallProperty;
    export function objectTypeIndexer(id?: Expression, key?: FlowTypeAnnotation, value?: FlowTypeAnnotation): ObjectTypeIndexer;
    export function objectTypeProperty(key?: Expression, value?: FlowTypeAnnotation): ObjectTypeProperty;
    export function qualifiedTypeIdentifier(id?: Identifier, qualification?: Identifier | QualifiedTypeIdentifier): QualifiedTypeIdentifier;
    export function unionTypeAnnotation(types?: FlowTypeAnnotation[]): UnionTypeAnnotation;
    export function voidTypeAnnotation(): VoidTypeAnnotation;
    export function jSXAttribute(name?: JSXIdentifier | JSXNamespacedName, value?: JSXElement | StringLiteral | JSXExpressionContainer): JSXAttribute;
    export function jSXClosingElement(name?: JSXIdentifier | JSXMemberExpression): JSXClosingElement;
    export function jSXElement(openingElement?: JSXOpeningElement, closingElement?: JSXClosingElement, children?: Array<JSXElement | JSXExpressionContainer | JSXText>, selfClosing?: boolean): JSXElement;
    export function jSXEmptyExpression(): JSXEmptyExpression;
    export function jSXExpressionContainer(expression?: Expression): JSXExpressionContainer;
    export function jSXIdentifier(name?: string): JSXIdentifier;
    export function jSXMemberExpression(object?: JSXMemberExpression | JSXIdentifier, property?: JSXIdentifier): JSXMemberExpression;
    export function jSXNamespacedName(namespace?: JSXIdentifier, name?: JSXIdentifier): JSXNamespacedName;
    export function jSXOpeningElement(name?: JSXIdentifier | JSXMemberExpression, attributes?: JSXAttribute[], selfClosing?: boolean): JSXOpeningElement;
    export function jSXSpreadAttribute(argument?: Expression): JSXSpreadAttribute;
    export function jSXText(value?: string): JSXText;
    export function noop(): Noop;
    export function parenthesizedExpression(expression?: Expression): ParenthesizedExpression;
    export function awaitExpression(argument?: Expression): AwaitExpression;
    export function bindExpression(object?: Expression, callee?: Expression): BindExpression;
    export function decorator(expression?: Expression): Decorator;
    export function doExpression(body?: BlockStatement): DoExpression;
    export function exportDefaultSpecifier(exported?: Identifier): ExportDefaultSpecifier;
    export function exportNamespaceSpecifier(exported?: Identifier): ExportNamespaceSpecifier;
    export function restProperty(argument?: LVal): RestProperty;
    export function spreadProperty(argument?: Expression): SpreadProperty;

    export function isArrayExpression(node: Object, opts?: Object): node is ArrayExpression;
    export function isAssignmentExpression(node: Object, opts?: Object): node is AssignmentExpression;
    export function isBinaryExpression(node: Object, opts?: Object): node is BinaryExpression;
    export function isDirective(node: Object, opts?: Object): node is Directive;
    export function isDirectiveLiteral(node: Object, opts?: Object): node is DirectiveLiteral;
    export function isBlockStatement(node: Object, opts?: Object): node is BlockStatement;
    export function isBreakStatement(node: Object, opts?: Object): node is BreakStatement;
    export function isCallExpression(node: Object, opts?: Object): node is CallExpression;
    export function isCatchClause(node: Object, opts?: Object): node is CatchClause;
    export function isConditionalExpression(node: Object, opts?: Object): node is ConditionalExpression;
    export function isContinueStatement(node: Object, opts?: Object): node is ContinueStatement;
    export function isDebuggerStatement(node: Object, opts?: Object): node is DebuggerStatement;
    export function isDoWhileStatement(node: Object, opts?: Object): node is DoWhileStatement;
    export function isEmptyStatement(node: Object, opts?: Object): node is EmptyStatement;
    export function isExpressionStatement(node: Object, opts?: Object): node is ExpressionStatement;
    export function isFile(node: Object, opts?: Object): node is File;
    export function isForInStatement(node: Object, opts?: Object): node is ForInStatement;
    export function isForStatement(node: Object, opts?: Object): node is ForStatement;
    export function isFunctionDeclaration(node: Object, opts?: Object): node is FunctionDeclaration;
    export function isFunctionExpression(node: Object, opts?: Object): node is FunctionExpression;
    export function isIdentifier(node: Object, opts?: Object): node is Identifier;
    export function isIfStatement(node: Object, opts?: Object): node is IfStatement;
    export function isLabeledStatement(node: Object, opts?: Object): node is LabeledStatement;
    export function isStringLiteral(node: Object, opts?: Object): node is StringLiteral;
    export function isNumericLiteral(node: Object, opts?: Object): node is NumericLiteral;
    export function isNullLiteral(node: Object, opts?: Object): node is NullLiteral;
    export function isBooleanLiteral(node: Object, opts?: Object): node is BooleanLiteral;
    export function isRegExpLiteral(node: Object, opts?: Object): node is RegExpLiteral;
    export function isLogicalExpression(node: Object, opts?: Object): node is LogicalExpression;
    export function isMemberExpression(node: Object, opts?: Object): node is MemberExpression;
    export function isNewExpression(node: Object, opts?: Object): node is NewExpression;
    export function isProgram(node: Object, opts?: Object): node is Program;
    export function isObjectExpression(node: Object, opts?: Object): node is ObjectExpression;
    export function isObjectMethod(node: Object, opts?: Object): node is ObjectMethod;
    export function isObjectProperty(node: Object, opts?: Object): node is ObjectProperty;
    export function isRestElement(node: Object, opts?: Object): node is RestElement;
    export function isReturnStatement(node: Object, opts?: Object): node is ReturnStatement;
    export function isSequenceExpression(node: Object, opts?: Object): node is SequenceExpression;
    export function isSwitchCase(node: Object, opts?: Object): node is SwitchCase;
    export function isSwitchStatement(node: Object, opts?: Object): node is SwitchStatement;
    export function isThisExpression(node: Object, opts?: Object): node is ThisExpression;
    export function isThrowStatement(node: Object, opts?: Object): node is ThrowStatement;
    export function isTryStatement(node: Object, opts?: Object): node is TryStatement;
    export function isUnaryExpression(node: Object, opts?: Object): node is UnaryExpression;
    export function isUpdateExpression(node: Object, opts?: Object): node is UpdateExpression;
    export function isVariableDeclaration(node: Object, opts?: Object): node is VariableDeclaration;
    export function isVariableDeclarator(node: Object, opts?: Object): node is VariableDeclarator;
    export function isWhileStatement(node: Object, opts?: Object): node is WhileStatement;
    export function isWithStatement(node: Object, opts?: Object): node is WithStatement;
    export function isAssignmentPattern(node: Object, opts?: Object): node is AssignmentPattern;
    export function isArrayPattern(node: Object, opts?: Object): node is ArrayPattern;
    export function isArrowFunctionExpression(node: Object, opts?: Object): node is ArrowFunctionExpression;
    export function isClassBody(node: Object, opts?: Object): node is ClassBody;
    export function isClassDeclaration(node: Object, opts?: Object): node is ClassDeclaration;
    export function isClassExpression(node: Object, opts?: Object): node is ClassExpression;
    export function isExportAllDeclaration(node: Object, opts?: Object): node is ExportAllDeclaration;
    export function isExportDefaultDeclaration(node: Object, opts?: Object): node is ExportDefaultDeclaration;
    export function isExportNamedDeclaration(node: Object, opts?: Object): node is ExportNamedDeclaration;
    export function isExportSpecifier(node: Object, opts?: Object): node is ExportSpecifier;
    export function isForOfStatement(node: Object, opts?: Object): node is ForOfStatement;
    export function isImportDeclaration(node: Object, opts?: Object): node is ImportDeclaration;
    export function isImportDefaultSpecifier(node: Object, opts?: Object): node is ImportDefaultSpecifier;
    export function isImportNamespaceSpecifier(node: Object, opts?: Object): node is ImportNamespaceSpecifier;
    export function isImportSpecifier(node: Object, opts?: Object): node is ImportSpecifier;
    export function isMetaProperty(node: Object, opts?: Object): node is MetaProperty;
    export function isClassMethod(node: Object, opts?: Object): node is ClassMethod;
    export function isObjectPattern(node: Object, opts?: Object): node is ObjectPattern;
    export function isSpreadElement(node: Object, opts?: Object): node is SpreadElement;
    export function isSuper(node: Object, opts?: Object): node is Super;
    export function isTaggedTemplateExpression(node: Object, opts?: Object): node is TaggedTemplateExpression;
    export function isTemplateElement(node: Object, opts?: Object): node is TemplateElement;
    export function isTemplateLiteral(node: Object, opts?: Object): node is TemplateLiteral;
    export function isYieldExpression(node: Object, opts?: Object): node is YieldExpression;
    export function isAnyTypeAnnotation(node: Object, opts?: Object): node is AnyTypeAnnotation;
    export function isArrayTypeAnnotation(node: Object, opts?: Object): node is ArrayTypeAnnotation;
    export function isBooleanTypeAnnotation(node: Object, opts?: Object): node is BooleanTypeAnnotation;
    export function isBooleanLiteralTypeAnnotation(node: Object, opts?: Object): node is BooleanLiteralTypeAnnotation;
    export function isNullLiteralTypeAnnotation(node: Object, opts?: Object): node is NullLiteralTypeAnnotation;
    export function isClassImplements(node: Object, opts?: Object): node is ClassImplements;
    export function isClassProperty(node: Object, opts?: Object): node is ClassProperty;
    export function isDeclareClass(node: Object, opts?: Object): node is DeclareClass;
    export function isDeclareFunction(node: Object, opts?: Object): node is DeclareFunction;
    export function isDeclareInterface(node: Object, opts?: Object): node is DeclareInterface;
    export function isDeclareModule(node: Object, opts?: Object): node is DeclareModule;
    export function isDeclareTypeAlias(node: Object, opts?: Object): node is DeclareTypeAlias;
    export function isDeclareVariable(node: Object, opts?: Object): node is DeclareVariable;
    export function isExistentialTypeParam(node: Object, opts?: Object): node is ExistentialTypeParam;
    export function isFunctionTypeAnnotation(node: Object, opts?: Object): node is FunctionTypeAnnotation;
    export function isFunctionTypeParam(node: Object, opts?: Object): node is FunctionTypeParam;
    export function isGenericTypeAnnotation(node: Object, opts?: Object): node is GenericTypeAnnotation;
    export function isInterfaceExtends(node: Object, opts?: Object): node is InterfaceExtends;
    export function isInterfaceDeclaration(node: Object, opts?: Object): node is InterfaceDeclaration;
    export function isIntersectionTypeAnnotation(node: Object, opts?: Object): node is IntersectionTypeAnnotation;
    export function isMixedTypeAnnotation(node: Object, opts?: Object): node is MixedTypeAnnotation;
    export function isNullableTypeAnnotation(node: Object, opts?: Object): node is NullableTypeAnnotation;
    export function isNumericLiteralTypeAnnotation(node: Object, opts?: Object): node is NumericLiteralTypeAnnotation;
    export function isNumberTypeAnnotation(node: Object, opts?: Object): node is NumberTypeAnnotation;
    export function isStringLiteralTypeAnnotation(node: Object, opts?: Object): node is StringLiteralTypeAnnotation;
    export function isStringTypeAnnotation(node: Object, opts?: Object): node is StringTypeAnnotation;
    export function isThisTypeAnnotation(node: Object, opts?: Object): node is ThisTypeAnnotation;
    export function isTupleTypeAnnotation(node: Object, opts?: Object): node is TupleTypeAnnotation;
    export function isTypeofTypeAnnotation(node: Object, opts?: Object): node is TypeofTypeAnnotation;
    export function isTypeAlias(node: Object, opts?: Object): node is TypeAlias;
    export function isTypeAnnotation(node: Object, opts?: Object): node is TypeAnnotation;
    export function isTypeCastExpression(node: Object, opts?: Object): node is TypeCastExpression;
    export function isTypeParameterDeclaration(node: Object, opts?: Object): node is TypeParameterDeclaration;
    export function isTypeParameterInstantiation(node: Object, opts?: Object): node is TypeParameterInstantiation;
    export function isObjectTypeAnnotation(node: Object, opts?: Object): node is ObjectTypeAnnotation;
    export function isObjectTypeCallProperty(node: Object, opts?: Object): node is ObjectTypeCallProperty;
    export function isObjectTypeIndexer(node: Object, opts?: Object): node is ObjectTypeIndexer;
    export function isObjectTypeProperty(node: Object, opts?: Object): node is ObjectTypeProperty;
    export function isQualifiedTypeIdentifier(node: Object, opts?: Object): node is QualifiedTypeIdentifier;
    export function isUnionTypeAnnotation(node: Object, opts?: Object): node is UnionTypeAnnotation;
    export function isVoidTypeAnnotation(node: Object, opts?: Object): node is VoidTypeAnnotation;
    export function isJSXAttribute(node: Object, opts?: Object): node is JSXAttribute;
    export function isJSXClosingElement(node: Object, opts?: Object): node is JSXClosingElement;
    export function isJSXElement(node: Object, opts?: Object): node is JSXElement;
    export function isJSXEmptyExpression(node: Object, opts?: Object): node is JSXEmptyExpression;
    export function isJSXExpressionContainer(node: Object, opts?: Object): node is JSXExpressionContainer;
    export function isJSXIdentifier(node: Object, opts?: Object): node is JSXIdentifier;
    export function isJSXMemberExpression(node: Object, opts?: Object): node is JSXMemberExpression;
    export function isJSXNamespacedName(node: Object, opts?: Object): node is JSXNamespacedName;
    export function isJSXOpeningElement(node: Object, opts?: Object): node is JSXOpeningElement;
    export function isJSXSpreadAttribute(node: Object, opts?: Object): node is JSXSpreadAttribute;
    export function isJSXText(node: Object, opts?: Object): node is JSXText;
    export function isNoop(node: Object, opts?: Object): node is Noop;
    export function isParenthesizedExpression(node: Object, opts?: Object): node is ParenthesizedExpression;
    export function isAwaitExpression(node: Object, opts?: Object): node is AwaitExpression;
    export function isBindExpression(node: Object, opts?: Object): node is BindExpression;
    export function isDecorator(node: Object, opts?: Object): node is Decorator;
    export function isDoExpression(node: Object, opts?: Object): node is DoExpression;
    export function isExportDefaultSpecifier(node: Object, opts?: Object): node is ExportDefaultSpecifier;
    export function isExportNamespaceSpecifier(node: Object, opts?: Object): node is ExportNamespaceSpecifier;
    export function isRestProperty(node: Object, opts?: Object): node is RestProperty;
    export function isSpreadProperty(node: Object, opts?: Object): node is SpreadProperty;
    export function isExpression(node: Object, opts?: Object): node is Expression;
    export function isBinary(node: Object, opts?: Object): node is Binary;
    export function isScopable(node: Object, opts?: Object): node is Scopable;
    export function isBlockParent(node: Object, opts?: Object): node is BlockParent;
    export function isBlock(node: Object, opts?: Object): node is Block;
    export function isStatement(node: Object, opts?: Object): node is Statement;
    export function isTerminatorless(node: Object, opts?: Object): node is Terminatorless;
    export function isCompletionStatement(node: Object, opts?: Object): node is CompletionStatement;
    export function isConditional(node: Object, opts?: Object): node is Conditional;
    export function isLoop(node: Object, opts?: Object): node is Loop;
    export function isWhile(node: Object, opts?: Object): node is While;
    export function isExpressionWrapper(node: Object, opts?: Object): node is ExpressionWrapper;
    export function isFor(node: Object, opts?: Object): node is For;
    export function isForXStatement(node: Object, opts?: Object): node is ForXStatement;
    export function isFunction(node: Object, opts?: Object): node is Function;
    export function isFunctionParent(node: Object, opts?: Object): node is FunctionParent;
    export function isPureish(node: Object, opts?: Object): node is Pureish;
    export function isDeclaration(node: Object, opts?: Object): node is Declaration;
    export function isLVal(node: Object, opts?: Object): node is LVal;
    export function isLiteral(node: Object, opts?: Object): node is Literal;
    export function isImmutable(node: Object, opts?: Object): node is Immutable;
    export function isUserWhitespacable(node: Object, opts?: Object): node is UserWhitespacable;
    export function isMethod(node: Object, opts?: Object): node is Method;
    export function isObjectMember(node: Object, opts?: Object): node is ObjectMember;
    export function isProperty(node: Object, opts?: Object): node is Property;
    export function isUnaryLike(node: Object, opts?: Object): node is UnaryLike;
    export function isPattern(node: Object, opts?: Object): node is Pattern;
    export function isClass(node: Object, opts?: Object): node is Class;
    export function isModuleDeclaration(node: Object, opts?: Object): node is ModuleDeclaration;
    export function isExportDeclaration(node: Object, opts?: Object): node is ExportDeclaration;
    export function isModuleSpecifier(node: Object, opts?: Object): node is ModuleSpecifier;
    export function isFlow(node: Object, opts?: Object): node is Flow;
    export function isFlowBaseAnnotation(node: Object, opts?: Object): node is FlowBaseAnnotation;
    export function isFlowDeclaration(node: Object, opts?: Object): node is FlowDeclaration;
    export function isJSX(node: Object, opts?: Object): node is JSX;
    export function isNumberLiteral(node: Object, opts?: Object): node is NumericLiteral;
    export function isRegexLiteral(node: Object, opts?: Object): node is RegExpLiteral;

    export function isReferencedIdentifier(node: Object, opts?: Object): boolean;
    export function isReferencedMemberExpression(node: Object, opts?: Object): boolean;
    export function isBindingIdentifier(node: Object, opts?: Object): boolean;
    export function isScope(node: Object, opts?: Object): boolean;
    export function isReferenced(node: Object, opts?: Object): boolean;
    export function isBlockScoped(node: Object, opts?: Object): boolean;
    export function isVar(node: Object, opts?: Object): boolean;
    export function isUser(node: Object, opts?: Object): boolean;
    export function isGenerated(node: Object, opts?: Object): boolean;
    export function isPure(node: Object, opts?: Object): boolean;

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