// Jest Snapshot v1, https://goo.gl/fbAQLP

exports[`printBinaryExpression.js 1`] = `
====================================options=====================================
parsers: ["flow"]
printWidth: 80
                                                                                | printWidth
=====================================input======================================
'use babel';
/* @flow */

/*
 * Copyright (c) 2015-present, Facebook, Inc.
 * All rights reserved.
 *
 * This source code is licensed under the license found in the LICENSE file in
 * the root directory of this source tree.
 */

import type {BinaryExpression} from './types';

function printBinaryExpression(
  node: BinaryExpression,
) {
  console.log(node);
}

module.exports = printBinaryExpression;

=====================================output=====================================
"use babel";
/* @flow */

/*
 * Copyright (c) 2015-present, Facebook, Inc.
 * All rights reserved.
 *
 * This source code is licensed under the license found in the LICENSE file in
 * the root directory of this source tree.
 */

import type { BinaryExpression } from "./types";

function printBinaryExpression(node: BinaryExpression) {
  console.log(node);
}

module.exports = printBinaryExpression;

================================================================================
`;

exports[`types.js 1`] = `
====================================options=====================================
parsers: ["flow"]
printWidth: 80
                                                                                | printWidth
=====================================input======================================
/**
 * @flow
 */

'use strict';

/*
 * Flow types for the Babylon AST.
 */

// Abstract types. Something must extend these.

export type Comment = {
  type: 'CommentLine';
  _CommentLine: void;
  value: string;
  end: number;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
} | {
  type: 'CommentBlock';
  _CommentBlock: void;
  value: string;
  end: number;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
};

export type Declaration = {
  type: 'ClassBody';
  _ClassBody: void;
  body: Array<Node>;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'ClassDeclaration';
  _ClassDeclaration: void;
  body: ClassBody;
  id: ?Identifier;
  superClass: ?Expression;
  decorators: any;
  superTypeParameters: any;
  typeParameters: any;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'FunctionDeclaration';
  _FunctionDeclaration: void;
  body: BlockStatement;
  id: Identifier;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
  async: boolean;
  defaults: Array<?Expression>;
  expression: boolean;
  generator: boolean;
  params: Array<Pattern>;
  rest: ?Identifier;
  returnType: ?TypeAnnotation;
  typeParameters: ?TypeParameterDeclaration;
} | {
  type: 'MethodDefinition';
  _MethodDefinition: void;
  computed: boolean;
  key: Node;
  kind: 'constructor' | 'method' | 'get' | 'set';
  static: boolean;
  value: FunctionExpression;
  decorators: ?Array<Decorator>;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'VariableDeclaration';
  _VariableDeclaration: void;
  declarations: Array<VariableDeclarator>;
  kind: 'var' | 'let' | 'const';
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'ClassProperty';
  _ClassProperty: void;
  computed: boolean;
  key: Node;
  static: boolean;
  typeAnnotation: ?TypeAnnotation;
  value: ?Expression;
  decorators: Array<Decorator>;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type Expression = {
  type: 'ArrayExpression';
  _ArrayExpression: void;
  elements: Array<?Node>;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'AssignmentExpression';
  _AssignmentExpression: void;
  left: Pattern;
  operator: AssignmentOperator;
  right: Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'AwaitExpression';
  _AwaitExpression: void;
  all: boolean;
  argument: ?Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'BinaryExpression';
  _BinaryExpression: void;
  left: Expression;
  operator: BinaryOperator;
  right: Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'BindExpression';
  _BindExpression: void;
  callee: Node;
  object: Node;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'CallExpression';
  _CallExpression: void;
  arguments: Array<Node>;
  callee: Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'ClassExpression';
  _ClassExpression: void;
  body: ClassBody;
  id: ?Identifier;
  superClass: ?Expression;
  decorators: any;
  superTypeParameters: any;
  typeParameters: any;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'ComprehensionExpression';
  _ComprehensionExpression: void;
  body: Expression;
  blocks: Array<ComprehensionBlock>;
  filter: ?Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'ConditionalExpression';
  _ConditionalExpression: void;
  alternate: Expression;
  consequent: Expression;
  test: Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'DoExpression';
  _DoExpression: void;
  body: Statement;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'FunctionExpression';
  _FunctionExpression: void;
  body: BlockStatement;
  id: ?Identifier;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
  async: boolean;
  defaults: Array<?Expression>;
  expression: boolean;
  generator: boolean;
  params: Array<Pattern>;
  rest: ?Identifier;
  returnType: ?TypeAnnotation;
  typeParameters: ?TypeParameterDeclaration;
} | {
  type: 'Identifier';
  _Identifier: void;
  name: string;
  typeAnnotation: ?TypeAnnotation;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'Literal';
  _Literal: void;
  raw: string;
  regex: ?{pattern: string, flags: string};
  value: ?(string | boolean | number | RegExp);
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'LogicalExpression';
  _LogicalExpression: void;
  left: Expression;
  operator: LogicalOperator;
  right: Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'MemberExpression';
  _MemberExpression: void;
  computed: boolean;
  object: Expression;
  property: Node;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'NewExpression';
  _NewExpression: void;
  arguments: Array<Node>;
  callee: Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'ObjectExpression';
  _ObjectExpression: void;
  properties: Array<Node>;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'SequenceExpression';
  _SequenceExpression: void;
  expression: Array<Expression>;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'TaggedTemplateExpression';
  _TaggedTemplateExpression: void;
  quasi: TemplateLiteral;
  tag: Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'TemplateLiteral';
  _TemplateLiteral: void;
  expressions: Array<Expression>;
  quasis: Array<TemplateElement>;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'ThisExpression';
  _ThisExpression: void;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'UnaryExpression';
  _UnaryExpression: void;
  argument: Expression;
  operator: UnaryOperator;
  prefix: true;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'UpdateExpression';
  _UpdateExpression: void;
  argument: Expression;
  operator: UpdateOperator;
  prefix: boolean;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'YieldExpression';
  _YieldExpression: void;
  argument: ?Expression;
  delegate: boolean;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'TypeCastExpression';
  _TypeCastExpression: void;
  expression: Expression;
  typeAnnotation: TypeAnnotation;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'JSXElement';
  _JSXElement: void;
  children: Array<Node>;
  closingElement: ?JSXClosingElement;
  openingElement: JSXOpeningElement;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'JSXEmptyExpression';
  _JSXEmptyExpression: void;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'JSXExpressionContainer';
  _JSXExpressionContainer: void;
  expression: Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'JSXMemberExpression';
  _JSXMemberExpression: void;
  computed: boolean;
  object: Node;
  property: JSXIdentifier;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type Function = {
  type: 'ArrowFunctionExpression';
  _ArrowFunctionExpression: void;
  body: Node;
  id: ?Identifier;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
  async: boolean;
  defaults: Array<?Expression>;
  expression: boolean;
  generator: boolean;
  params: Array<Pattern>;
  rest: ?Identifier;
  returnType: ?TypeAnnotation;
  typeParameters: ?TypeParameterDeclaration;
} | {
  type: 'FunctionDeclaration';
  _FunctionDeclaration: void;
  body: BlockStatement;
  id: Identifier;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
  async: boolean;
  defaults: Array<?Expression>;
  expression: boolean;
  generator: boolean;
  params: Array<Pattern>;
  rest: ?Identifier;
  returnType: ?TypeAnnotation;
  typeParameters: ?TypeParameterDeclaration;
} | {
  type: 'FunctionExpression';
  _FunctionExpression: void;
  body: BlockStatement;
  id: ?Identifier;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
  async: boolean;
  defaults: Array<?Expression>;
  expression: boolean;
  generator: boolean;
  params: Array<Pattern>;
  rest: ?Identifier;
  returnType: ?TypeAnnotation;
  typeParameters: ?TypeParameterDeclaration;
};

export type Node = {
  type: 'ArrayExpression';
  _ArrayExpression: void;
  elements: Array<?Node>;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'ArrayPattern';
  _ArrayPattern: void;
  elements: Array<?Node>;
  typeAnnotation: ?TypeAnnotation;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'ArrowFunctionExpression';
  _ArrowFunctionExpression: void;
  body: Node;
  id: ?Identifier;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
  async: boolean;
  defaults: Array<?Expression>;
  expression: boolean;
  generator: boolean;
  params: Array<Pattern>;
  rest: ?Identifier;
  returnType: ?TypeAnnotation;
  typeParameters: ?TypeParameterDeclaration;
} | {
  type: 'AssignmentExpression';
  _AssignmentExpression: void;
  left: Pattern;
  operator: AssignmentOperator;
  right: Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'AssignmentPattern';
  _AssignmentPattern: void;
  left: Pattern;
  right: Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'AwaitExpression';
  _AwaitExpression: void;
  all: boolean;
  argument: ?Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'BinaryExpression';
  _BinaryExpression: void;
  left: Expression;
  operator: BinaryOperator;
  right: Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'BindExpression';
  _BindExpression: void;
  callee: Node;
  object: Node;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'BlockStatement';
  _BlockStatement: void;
  body: Array<Statement>;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'BreakStatement';
  _BreakStatement: void;
  label: ?Identifier;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'CallExpression';
  _CallExpression: void;
  arguments: Array<Node>;
  callee: Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'CatchClause';
  _CatchClause: void;
  body: BlockStatement;
  param: Pattern;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'ClassBody';
  _ClassBody: void;
  body: Array<Node>;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'ClassDeclaration';
  _ClassDeclaration: void;
  body: ClassBody;
  id: ?Identifier;
  superClass: ?Expression;
  decorators: any;
  superTypeParameters: any;
  typeParameters: any;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'ClassExpression';
  _ClassExpression: void;
  body: ClassBody;
  id: ?Identifier;
  superClass: ?Expression;
  decorators: any;
  superTypeParameters: any;
  typeParameters: any;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'ComprehensionBlock';
  _ComprehensionBlock: void;
  each: boolean;
  left: Pattern;
  right: Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'ComprehensionExpression';
  _ComprehensionExpression: void;
  body: Expression;
  blocks: Array<ComprehensionBlock>;
  filter: ?Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'ConditionalExpression';
  _ConditionalExpression: void;
  alternate: Expression;
  consequent: Expression;
  test: Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'ContinueStatement';
  _ContinueStatement: void;
  label: ?Identifier;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'Decorator';
  _Decorator: void;
  expression: Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'DebuggerStatement';
  _DebuggerStatement: void;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'DoWhileStatement';
  _DoWhileStatement: void;
  body: Statement;
  test: Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'DoExpression';
  _DoExpression: void;
  body: Statement;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'EmptyStatement';
  _EmptyStatement: void;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'ExpressionStatement';
  _ExpressionStatement: void;
  expression: Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'File';
  _File: void;
  program: Program;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'ForInStatement';
  _ForInStatement: void;
  body: Statement;
  left: Node;
  right: Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'ForOfStatement';
  _ForOfStatement: void;
  body: Statement;
  left: Node;
  right: Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'ForStatement';
  _ForStatement: void;
  init: ?Node;
  test: ?Expression;
  update: ?Expression;
  body: Statement;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'FunctionDeclaration';
  _FunctionDeclaration: void;
  body: BlockStatement;
  id: Identifier;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
  async: boolean;
  defaults: Array<?Expression>;
  expression: boolean;
  generator: boolean;
  params: Array<Pattern>;
  rest: ?Identifier;
  returnType: ?TypeAnnotation;
  typeParameters: ?TypeParameterDeclaration;
} | {
  type: 'FunctionExpression';
  _FunctionExpression: void;
  body: BlockStatement;
  id: ?Identifier;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
  async: boolean;
  defaults: Array<?Expression>;
  expression: boolean;
  generator: boolean;
  params: Array<Pattern>;
  rest: ?Identifier;
  returnType: ?TypeAnnotation;
  typeParameters: ?TypeParameterDeclaration;
} | {
  type: 'Identifier';
  _Identifier: void;
  name: string;
  typeAnnotation: ?TypeAnnotation;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'IfStatement';
  _IfStatement: void;
  alternate: ?Statement;
  consequent: Statement;
  test: Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'ImportDefaultSpecifier';
  _ImportDefaultSpecifier: void;
  local: Node;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'ImportNamespaceSpecifier';
  _ImportNamespaceSpecifier: void;
  local: Node;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'ImportDeclaration';
  _ImportDeclaration: void;
  specifiers: Array<Node>;
  source: Literal;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'ImportSpecifier';
  _ImportSpecifier: void;
  imported: Node;
  local: Node;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'LabeledStatement';
  _LabeledStatement: void;
  body: Statement;
  label: Identifier;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'Literal';
  _Literal: void;
  raw: string;
  regex: ?{pattern: string, flags: string};
  value: ?(string | boolean | number | RegExp);
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'LogicalExpression';
  _LogicalExpression: void;
  left: Expression;
  operator: LogicalOperator;
  right: Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'MemberExpression';
  _MemberExpression: void;
  computed: boolean;
  object: Expression;
  property: Node;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'MetaProperty';
  _MetaProperty: void;
  meta: Node;
  property: Node;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'MethodDefinition';
  _MethodDefinition: void;
  computed: boolean;
  key: Node;
  kind: 'constructor' | 'method' | 'get' | 'set';
  static: boolean;
  value: FunctionExpression;
  decorators: ?Array<Decorator>;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'NewExpression';
  _NewExpression: void;
  arguments: Array<Node>;
  callee: Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'Noop';
  _Noop: void;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'ObjectExpression';
  _ObjectExpression: void;
  properties: Array<Node>;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'ObjectPattern';
  _ObjectPattern: void;
  properties: Array<Node>;
  typeAnnotation: ?TypeAnnotation;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'Program';
  _Program: void;
  body: Array<Statement>;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'Property';
  _Property: void;
  computed: boolean;
  key: Node;
  kind: 'init' | 'get' | 'set';
  method: boolean;
  shorthand: boolean;
  value: Node;
  decorators: ?Array<Decorator>;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'RestElement';
  _RestElement: void;
  argument: Pattern;
  typeAnnotation: ?TypeAnnotation;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'ReturnStatement';
  _ReturnStatement: void;
  argument: ?Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'SequenceExpression';
  _SequenceExpression: void;
  expression: Array<Expression>;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'SpreadElement';
  _SpreadElement: void;
  argument: Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'SpreadProperty';
  _SpreadProperty: void;
  argument: Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'Super';
  _Super: void;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'SwitchCase';
  _SwitchCase: void;
  consequent: Array<Statement>;
  test: ?Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'SwitchStatement';
  _SwitchStatement: void;
  cases: Array<SwitchCase>;
  discriminant: Expression;
  lexical: boolean;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'TaggedTemplateExpression';
  _TaggedTemplateExpression: void;
  quasi: TemplateLiteral;
  tag: Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'TemplateElement';
  _TemplateElement: void;
  tail: boolean;
  value: {cooked: string, raw: string};
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'TemplateLiteral';
  _TemplateLiteral: void;
  expressions: Array<Expression>;
  quasis: Array<TemplateElement>;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'ThisExpression';
  _ThisExpression: void;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'ThrowStatement';
  _ThrowStatement: void;
  argument: Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'TryStatement';
  _TryStatement: void;
  block: BlockStatement;
  finalizer: ?BlockStatement;
  guardedHandlers: Array<CatchClause>;
  handler: ?CatchClause;
  handlers: ?Array<CatchClause>;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'UnaryExpression';
  _UnaryExpression: void;
  argument: Expression;
  operator: UnaryOperator;
  prefix: true;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'UpdateExpression';
  _UpdateExpression: void;
  argument: Expression;
  operator: UpdateOperator;
  prefix: boolean;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'VariableDeclaration';
  _VariableDeclaration: void;
  declarations: Array<VariableDeclarator>;
  kind: 'var' | 'let' | 'const';
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'VariableDeclarator';
  _VariableDeclarator: void;
  id: Pattern;
  init: ?Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'WhileStatement';
  _WhileStatement: void;
  body: Statement;
  test: Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'WithStatement';
  _WithStatement: void;
  body: Statement;
  object: Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'YieldExpression';
  _YieldExpression: void;
  argument: ?Expression;
  delegate: boolean;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'ExportAllDeclaration';
  _ExportAllDeclaration: void;
  exported: Node;
  source: Node;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'ExportDefaultDeclaration';
  _ExportDefaultDeclaration: void;
  declaration: Node;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'ExportNamedDeclaration';
  _ExportNamedDeclaration: void;
  declaration: Node;
  source: Literal;
  specifiers: Array<Node>;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'ExportDefaultSpecifier';
  _ExportDefaultSpecifier: void;
  exported: Node;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'ExportNamespaceSpecifier';
  _ExportNamespaceSpecifier: void;
  exported: Node;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'ExportSpecifier';
  _ExportSpecifier: void;
  local: Node;
  exported: Node;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'AnyTypeAnnotation';
  _AnyTypeAnnotation: void;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'ArrayTypeAnnotation';
  _ArrayTypeAnnotation: void;
  elementType: Type;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'BooleanLiteralTypeAnnotation';
  _BooleanLiteralTypeAnnotation: void;
  raw: string;
  value: boolean;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'BooleanTypeAnnotation';
  _BooleanTypeAnnotation: void;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'ClassImplements';
  _ClassImplements: void;
  id: Identifier;
  typeParameters: ?TypeParameterInstantiation;
  superClass: ?Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'ClassProperty';
  _ClassProperty: void;
  computed: boolean;
  key: Node;
  static: boolean;
  typeAnnotation: ?TypeAnnotation;
  value: ?Expression;
  decorators: Array<Decorator>;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'DeclareClass';
  _DeclareClass: void;
  body: ObjectTypeAnnotation;
  extends: Array<InterfaceExtends>;
  id: Identifier;
  typeParameters: ?TypeParameterDeclaration;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'DeclareFunction';
  _DeclareFunction: void;
  id: Identifier;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'DeclareModule';
  _DeclareModule: void;
  body: BlockStatement;
  id: Node;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'DeclareVariable';
  _DeclareVariable: void;
  id: Identifier;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'FunctionTypeAnnotation';
  _FunctionTypeAnnotation: void;
  params: Array<FunctionTypeParam>;
  rest: ?FunctionTypeParam;
  returnType: Type;
  typeParameters: ?TypeParameterDeclaration;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'FunctionTypeParam';
  _FunctionTypeParam: void;
  name: Identifier;
  optional: boolean;
  typeAnnotation: Type;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'GenericTypeAnnotation';
  _GenericTypeAnnotation: void;
  id: Node;
  typeParameters: ?TypeParameterInstantiation;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'InterfaceExtends';
  _InterfaceExtends: void;
  id: Identifier;
  typeParameters: ?TypeParameterInstantiation;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'InterfaceDeclaration';
  _InterfaceDeclaration: void;
  body: ObjectTypeAnnotation;
  extends: Array<InterfaceExtends>;
  id: Identifier;
  typeParameters: ?TypeParameterDeclaration;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'IntersectionTypeAnnotation';
  _IntersectionTypeAnnotation: void;
  types: Array<Type>;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'MixedTypeAnnotation';
  _MixedTypeAnnotation: void;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'NullableTypeAnnotation';
  _NullableTypeAnnotation: void;
  typeAnnotation: Type;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'NumberLiteralTypeAnnotation';
  _NumberLiteralTypeAnnotation: void;
  raw: string;
  value: number;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'NumberTypeAnnotation';
  _NumberTypeAnnotation: void;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'StringLiteralTypeAnnotation';
  _StringLiteralTypeAnnotation: void;
  raw: string;
  value: string;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'StringTypeAnnotation';
  _StringTypeAnnotation: void;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'TupleTypeAnnotation';
  _TupleTypeAnnotation: void;
  types: Array<Type>;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'TypeofTypeAnnotation';
  _TypeofTypeAnnotation: void;
  argument: Type;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'TypeAlias';
  _TypeAlias: void;
  id: Identifier;
  right: Type;
  typeParameters: ?TypeParameterDeclaration;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'TypeAnnotation';
  _TypeAnnotation: void;
  typeAnnotation: Type;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'TypeCastExpression';
  _TypeCastExpression: void;
  expression: Expression;
  typeAnnotation: TypeAnnotation;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'TypeParameterDeclaration';
  _TypeParameterDeclaration: void;
  params: Array<Identifier>;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'TypeParameterInstantiation';
  _TypeParameterInstantiation: void;
  params: Array<Type>;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'ObjectTypeAnnotation';
  _ObjectTypeAnnotation: void;
  callProperties: Array<ObjectTypeCallProperty>;
  indexers: Array<ObjectTypeIndexer>;
  properties: Array<ObjectTypeProperty>;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'ObjectTypeCallProperty';
  _ObjectTypeCallProperty: void;
  static: boolean;
  value: FunctionTypeAnnotation;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'ObjectTypeIndexer';
  _ObjectTypeIndexer: void;
  id: Identifier;
  key: Type;
  value: Type;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'ObjectTypeProperty';
  _ObjectTypeProperty: void;
  key: Node;
  optional: boolean;
  value: Type;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'QualifiedTypeIdentifier';
  _QualifiedTypeIdentifier: void;
  id: Identifier;
  qualification: Node;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'UnionTypeAnnotation';
  _UnionTypeAnnotation: void;
  types: Array<Type>;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'VoidTypeAnnotation';
  _VoidTypeAnnotation: void;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'JSXAttribute';
  _JSXAttribute: void;
  name: Node;
  value: ?Node;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'JSXClosingElement';
  _JSXClosingElement: void;
  name: Node;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'JSXElement';
  _JSXElement: void;
  children: Array<Node>;
  closingElement: ?JSXClosingElement;
  openingElement: JSXOpeningElement;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'JSXEmptyExpression';
  _JSXEmptyExpression: void;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'JSXExpressionContainer';
  _JSXExpressionContainer: void;
  expression: Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'JSXIdentifier';
  _JSXIdentifier: void;
  name: string;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'JSXMemberExpression';
  _JSXMemberExpression: void;
  computed: boolean;
  object: Node;
  property: JSXIdentifier;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'JSXNamespacedName';
  _JSXNamespacedName: void;
  name: JSXIdentifier;
  namespace: JSXIdentifier;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'JSXOpeningElement';
  _JSXOpeningElement: void;
  attributes: Array<Node>;
  name: Array<Node>;
  selfClosing: boolean;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'JSXSpreadAttribute';
  _JSXSpreadAttribute: void;
  argument: Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type Pattern = {
  type: 'ArrayPattern';
  _ArrayPattern: void;
  elements: Array<?Node>;
  typeAnnotation: ?TypeAnnotation;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'AssignmentPattern';
  _AssignmentPattern: void;
  left: Pattern;
  right: Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'Identifier';
  _Identifier: void;
  name: string;
  typeAnnotation: ?TypeAnnotation;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'ObjectPattern';
  _ObjectPattern: void;
  properties: Array<Node>;
  typeAnnotation: ?TypeAnnotation;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'RestElement';
  _RestElement: void;
  argument: Pattern;
  typeAnnotation: ?TypeAnnotation;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type Statement = {
  type: 'BlockStatement';
  _BlockStatement: void;
  body: Array<Statement>;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'BreakStatement';
  _BreakStatement: void;
  label: ?Identifier;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'ContinueStatement';
  _ContinueStatement: void;
  label: ?Identifier;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'DoWhileStatement';
  _DoWhileStatement: void;
  body: Statement;
  test: Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'EmptyStatement';
  _EmptyStatement: void;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'ExpressionStatement';
  _ExpressionStatement: void;
  expression: Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'ForInStatement';
  _ForInStatement: void;
  body: Statement;
  left: Node;
  right: Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'ForOfStatement';
  _ForOfStatement: void;
  body: Statement;
  left: Node;
  right: Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'ForStatement';
  _ForStatement: void;
  init: ?Node;
  test: ?Expression;
  update: ?Expression;
  body: Statement;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'IfStatement';
  _IfStatement: void;
  alternate: ?Statement;
  consequent: Statement;
  test: Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'LabeledStatement';
  _LabeledStatement: void;
  body: Statement;
  label: Identifier;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'ReturnStatement';
  _ReturnStatement: void;
  argument: ?Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'SwitchStatement';
  _SwitchStatement: void;
  cases: Array<SwitchCase>;
  discriminant: Expression;
  lexical: boolean;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'ThrowStatement';
  _ThrowStatement: void;
  argument: Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'TryStatement';
  _TryStatement: void;
  block: BlockStatement;
  finalizer: ?BlockStatement;
  guardedHandlers: Array<CatchClause>;
  handler: ?CatchClause;
  handlers: ?Array<CatchClause>;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'WhileStatement';
  _WhileStatement: void;
  body: Statement;
  test: Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'WithStatement';
  _WithStatement: void;
  body: Statement;
  object: Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'DeclareClass';
  _DeclareClass: void;
  body: ObjectTypeAnnotation;
  extends: Array<InterfaceExtends>;
  id: Identifier;
  typeParameters: ?TypeParameterDeclaration;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'DeclareFunction';
  _DeclareFunction: void;
  id: Identifier;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'DeclareModule';
  _DeclareModule: void;
  body: BlockStatement;
  id: Node;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'DeclareVariable';
  _DeclareVariable: void;
  id: Identifier;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'InterfaceDeclaration';
  _InterfaceDeclaration: void;
  body: ObjectTypeAnnotation;
  extends: Array<InterfaceExtends>;
  id: Identifier;
  typeParameters: ?TypeParameterDeclaration;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'TypeAlias';
  _TypeAlias: void;
  id: Identifier;
  right: Type;
  typeParameters: ?TypeParameterDeclaration;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type Type = {
  type: 'AnyTypeAnnotation';
  _AnyTypeAnnotation: void;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'ArrayTypeAnnotation';
  _ArrayTypeAnnotation: void;
  elementType: Type;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'BooleanLiteralTypeAnnotation';
  _BooleanLiteralTypeAnnotation: void;
  raw: string;
  value: boolean;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'BooleanTypeAnnotation';
  _BooleanTypeAnnotation: void;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'FunctionTypeAnnotation';
  _FunctionTypeAnnotation: void;
  params: Array<FunctionTypeParam>;
  rest: ?FunctionTypeParam;
  returnType: Type;
  typeParameters: ?TypeParameterDeclaration;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'GenericTypeAnnotation';
  _GenericTypeAnnotation: void;
  id: Node;
  typeParameters: ?TypeParameterInstantiation;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'IntersectionTypeAnnotation';
  _IntersectionTypeAnnotation: void;
  types: Array<Type>;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'MixedTypeAnnotation';
  _MixedTypeAnnotation: void;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'NullableTypeAnnotation';
  _NullableTypeAnnotation: void;
  typeAnnotation: Type;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'NumberLiteralTypeAnnotation';
  _NumberLiteralTypeAnnotation: void;
  raw: string;
  value: number;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'NumberTypeAnnotation';
  _NumberTypeAnnotation: void;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'StringLiteralTypeAnnotation';
  _StringLiteralTypeAnnotation: void;
  raw: string;
  value: string;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'StringTypeAnnotation';
  _StringTypeAnnotation: void;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'TupleTypeAnnotation';
  _TupleTypeAnnotation: void;
  types: Array<Type>;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'ObjectTypeAnnotation';
  _ObjectTypeAnnotation: void;
  callProperties: Array<ObjectTypeCallProperty>;
  indexers: Array<ObjectTypeIndexer>;
  properties: Array<ObjectTypeProperty>;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'UnionTypeAnnotation';
  _UnionTypeAnnotation: void;
  types: Array<Type>;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
} | {
  type: 'VoidTypeAnnotation';
  _VoidTypeAnnotation: void;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

// Concrete Types. Nothing can extend these.

export type CommentLine = {
  type: 'CommentLine';
  _CommentLine: void;
  value: string;
  end: number;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
};

export type CommentBlock = {
  type: 'CommentBlock';
  _CommentBlock: void;
  value: string;
  end: number;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
};

// Babel concrete types.

export type ArrayExpression = {
  type: 'ArrayExpression';
  _ArrayExpression: void;
  elements: Array<?Node>;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type ArrayPattern = {
  type: 'ArrayPattern';
  _ArrayPattern: void;
  elements: Array<?Node>;
  typeAnnotation: ?TypeAnnotation;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type ArrowFunctionExpression = {
  type: 'ArrowFunctionExpression';
  _ArrowFunctionExpression: void;
  body: Node;
  id: ?Identifier;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
  async: boolean;
  defaults: Array<?Expression>;
  expression: boolean;
  generator: boolean;
  params: Array<Pattern>;
  rest: ?Identifier;
  returnType: ?TypeAnnotation;
  typeParameters: ?TypeParameterDeclaration;
};

type AssignmentOperator =
  '=' |
  '+=' |
  '-=' |
  '*=' |
  '/=' |
  '%=' |
  '<<=' |
  '>>=' |
  '>>>=' |
  '|=' |
  '^=' |
  '&=';

export type AssignmentExpression = {
  type: 'AssignmentExpression';
  _AssignmentExpression: void;
  left: Pattern;
  operator: AssignmentOperator;
  right: Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type AssignmentPattern = {
  type: 'AssignmentPattern';
  _AssignmentPattern: void;
  left: Pattern;
  right: Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type AwaitExpression = {
  type: 'AwaitExpression';
  _AwaitExpression: void;
  all: boolean;
  argument: ?Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

type BinaryOperator =
  '==' |
  '!=' |
  '===' |
  '!==' |
  '<' |
  '<=' |
  '>' |
  '>=' |
  '<<' |
  '>>' |
  '>>>' |
  '+' |
  '-' |
  '*' |
  '/' |
  '%' |
  '&' |
  '|' |
  '^' |
  'in' |
  'instanceof' |
  '..';

export type BinaryExpression = {
  type: 'BinaryExpression';
  _BinaryExpression: void;
  left: Expression;
  operator: BinaryOperator;
  right: Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

// TODO: What is this?
export type BindExpression = {
  type: 'BindExpression';
  _BindExpression: void;
  callee: Node;
  object: Node;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type BlockStatement = {
  type: 'BlockStatement';
  _BlockStatement: void;
  body: Array<Statement>;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type BreakStatement = {
  type: 'BreakStatement';
  _BreakStatement: void;
  label: ?Identifier;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type CallExpression = {
  type: 'CallExpression';
  _CallExpression: void;
  arguments: Array<Node>;
  callee: Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type CatchClause = {
  type: 'CatchClause';
  _CatchClause: void;
  body: BlockStatement;
  param: Pattern;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type ClassBody = {
  type: 'ClassBody';
  _ClassBody: void;
  body: Array<Node>;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type ClassDeclaration = {
  type: 'ClassDeclaration';
  _ClassDeclaration: void;
  body: ClassBody;
  id: ?Identifier;
  superClass: ?Expression;
  decorators: any;
  superTypeParameters: any;
  typeParameters: any;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type ClassExpression = {
  type: 'ClassExpression';
  _ClassExpression: void;
  body: ClassBody;
  id: ?Identifier;
  superClass: ?Expression;
  decorators: any;
  superTypeParameters: any;
  typeParameters: any;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type ComprehensionBlock = {
  type: 'ComprehensionBlock';
  _ComprehensionBlock: void;
  each: boolean;
  left: Pattern;
  right: Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type ComprehensionExpression = {
  type: 'ComprehensionExpression';
  _ComprehensionExpression: void;
  body: Expression;
  blocks: Array<ComprehensionBlock>;
  filter: ?Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type ConditionalExpression = {
  type: 'ConditionalExpression';
  _ConditionalExpression: void;
  alternate: Expression;
  consequent: Expression;
  test: Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type ContinueStatement = {
  type: 'ContinueStatement';
  _ContinueStatement: void;
  label: ?Identifier;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

// TODO: Make this correct.
export type Decorator = {
  type: 'Decorator';
  _Decorator: void;
  expression: Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type DebuggerStatement = {
  type: 'DebuggerStatement';
  _DebuggerStatement: void;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type DoWhileStatement = {
  type: 'DoWhileStatement';
  _DoWhileStatement: void;
  body: Statement;
  test: Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

// TODO: Make this correct.
export type DoExpression = {
  type: 'DoExpression';
  _DoExpression: void;
  body: Statement;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type EmptyStatement = {
  type: 'EmptyStatement';
  _EmptyStatement: void;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type ExpressionStatement = {
  type: 'ExpressionStatement';
  _ExpressionStatement: void;
  expression: Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type File = {
  type: 'File';
  _File: void;
  program: Program;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type ForInStatement = {
  type: 'ForInStatement';
  _ForInStatement: void;
  body: Statement;
  left: Node;
  right: Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

// TODO: Make this correct.
export type ForOfStatement = {
  type: 'ForOfStatement';
  _ForOfStatement: void;
  body: Statement;
  left: Node;
  right: Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type ForStatement = {
  type: 'ForStatement';
  _ForStatement: void;
  init: ?Node;
  test: ?Expression;
  update: ?Expression;
  body: Statement;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type FunctionDeclaration = {
  type: 'FunctionDeclaration';
  _FunctionDeclaration: void;
  body: BlockStatement;
  id: Identifier;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
  async: boolean;
  defaults: Array<?Expression>;
  expression: boolean;
  generator: boolean;
  params: Array<Pattern>;
  rest: ?Identifier;
  returnType: ?TypeAnnotation;
  typeParameters: ?TypeParameterDeclaration;
};

export type FunctionExpression = {
  type: 'FunctionExpression';
  _FunctionExpression: void;
  body: BlockStatement;
  id: ?Identifier;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
  async: boolean;
  defaults: Array<?Expression>;
  expression: boolean;
  generator: boolean;
  params: Array<Pattern>;
  rest: ?Identifier;
  returnType: ?TypeAnnotation;
  typeParameters: ?TypeParameterDeclaration;
};

export type Identifier = {
  type: 'Identifier';
  _Identifier: void;
  name: string;
  typeAnnotation: ?TypeAnnotation;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type IfStatement = {
  type: 'IfStatement';
  _IfStatement: void;
  alternate: ?Statement;
  consequent: Statement;
  test: Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

// TODO: Make this correct.
export type ImportDefaultSpecifier = {
  type: 'ImportDefaultSpecifier';
  _ImportDefaultSpecifier: void;
  local: Node;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

// TODO: Make this correct.
export type ImportNamespaceSpecifier = {
  type: 'ImportNamespaceSpecifier';
  _ImportNamespaceSpecifier: void;
  local: Node;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

// TODO: Make this correct.
export type ImportDeclaration = {
  type: 'ImportDeclaration';
  _ImportDeclaration: void;
  specifiers: Array<Node>;
  source: Literal;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

// TODO: Make this correct.
export type ImportSpecifier = {
  type: 'ImportSpecifier';
  _ImportSpecifier: void;
  imported: Node;
  local: Node;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type LabeledStatement = {
  type: 'LabeledStatement';
  _LabeledStatement: void;
  body: Statement;
  label: Identifier;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type Literal = {
  type: 'Literal';
  _Literal: void;
  raw: string;
  regex: ?{pattern: string, flags: string};
  value: ?(string | boolean | number | RegExp);
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

type LogicalOperator = '||' | '&&';

export type LogicalExpression = {
  type: 'LogicalExpression';
  _LogicalExpression: void;
  left: Expression;
  operator: LogicalOperator;
  right: Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type MemberExpression = {
  type: 'MemberExpression';
  _MemberExpression: void;
  computed: boolean;
  object: Expression;
  property: Node;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

// TODO: Make this correct.
export type MetaProperty = {
  type: 'MetaProperty';
  _MetaProperty: void;
  meta: Node;
  property: Node;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type MethodDefinition = {
  type: 'MethodDefinition';
  _MethodDefinition: void;
  computed: boolean;
  key: Node;
  kind: 'constructor' | 'method' | 'get' | 'set';
  static: boolean;
  value: FunctionExpression;
  decorators: ?Array<Decorator>;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type NewExpression = {
  type: 'NewExpression';
  _NewExpression: void;
  arguments: Array<Node>;
  callee: Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type Noop = {
  type: 'Noop';
  _Noop: void;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type ObjectExpression = {
  type: 'ObjectExpression';
  _ObjectExpression: void;
  properties: Array<Node>;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type ObjectPattern = {
  type: 'ObjectPattern';
  _ObjectPattern: void;
  properties: Array<Node>;
  typeAnnotation: ?TypeAnnotation;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type Program = {
  type: 'Program';
  _Program: void;
  body: Array<Statement>;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type Property = {
  type: 'Property';
  _Property: void;
  computed: boolean;
  key: Node;
  kind: 'init' | 'get' | 'set';
  method: boolean;
  shorthand: boolean;
  value: Node;
  decorators: ?Array<Decorator>;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type RestElement = {
  type: 'RestElement';
  _RestElement: void;
  argument: Pattern;
  typeAnnotation: ?TypeAnnotation;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type ReturnStatement = {
  type: 'ReturnStatement';
  _ReturnStatement: void;
  argument: ?Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type SequenceExpression = {
  type: 'SequenceExpression';
  _SequenceExpression: void;
  expression: Array<Expression>;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type SpreadElement = {
  type: 'SpreadElement';
  _SpreadElement: void;
  argument: Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type SpreadProperty = {
  type: 'SpreadProperty';
  _SpreadProperty: void;
  argument: Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type Super = {
  type: 'Super';
  _Super: void;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type SwitchCase = {
  type: 'SwitchCase';
  _SwitchCase: void;
  consequent: Array<Statement>;
  test: ?Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type SwitchStatement = {
  type: 'SwitchStatement';
  _SwitchStatement: void;
  cases: Array<SwitchCase>;
  discriminant: Expression;
  lexical: boolean;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type TaggedTemplateExpression = {
  type: 'TaggedTemplateExpression';
  _TaggedTemplateExpression: void;
  quasi: TemplateLiteral;
  tag: Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type TemplateElement = {
  type: 'TemplateElement';
  _TemplateElement: void;
  tail: boolean;
  value: {cooked: string, raw: string};
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type TemplateLiteral = {
  type: 'TemplateLiteral';
  _TemplateLiteral: void;
  expressions: Array<Expression>;
  quasis: Array<TemplateElement>;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type ThisExpression = {
  type: 'ThisExpression';
  _ThisExpression: void;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type ThrowStatement = {
  type: 'ThrowStatement';
  _ThrowStatement: void;
  argument: Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type TryStatement = {
  type: 'TryStatement';
  _TryStatement: void;
  block: BlockStatement;
  finalizer: ?BlockStatement;
  guardedHandlers: Array<CatchClause>;
  handler: ?CatchClause;
  handlers: ?Array<CatchClause>;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

type UnaryOperator = '-' | '+' | '!' | '~' | 'typeof' | 'void' | 'delete';

export type UnaryExpression = {
  type: 'UnaryExpression';
  _UnaryExpression: void;
  argument: Expression;
  operator: UnaryOperator;
  prefix: true;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

type UpdateOperator = '++' | '--';

export type UpdateExpression = {
  type: 'UpdateExpression';
  _UpdateExpression: void;
  argument: Expression;
  operator: UpdateOperator;
  prefix: boolean;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type VariableDeclaration = {
  type: 'VariableDeclaration';
  _VariableDeclaration: void;
  declarations: Array<VariableDeclarator>;
  kind: 'var' | 'let' | 'const';
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type VariableDeclarator = {
  type: 'VariableDeclarator';
  _VariableDeclarator: void;
  id: Pattern;
  init: ?Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type WhileStatement = {
  type: 'WhileStatement';
  _WhileStatement: void;
  body: Statement;
  test: Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type WithStatement = {
  type: 'WithStatement';
  _WithStatement: void;
  body: Statement;
  object: Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type YieldExpression = {
  type: 'YieldExpression';
  _YieldExpression: void;
  argument: ?Expression;
  delegate: boolean;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

// TODO: Make this correct.
export type ExportAllDeclaration = {
  type: 'ExportAllDeclaration';
  _ExportAllDeclaration: void;
  exported: Node;
  source: Node;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

// TODO: Make this correct.
export type ExportDefaultDeclaration = {
  type: 'ExportDefaultDeclaration';
  _ExportDefaultDeclaration: void;
  declaration: Node;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

// TODO: Make this correct.
export type ExportNamedDeclaration = {
  type: 'ExportNamedDeclaration';
  _ExportNamedDeclaration: void;
  declaration: Node;
  source: Literal;
  specifiers: Array<Node>;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

// TODO: Make this correct.
export type ExportDefaultSpecifier = {
  type: 'ExportDefaultSpecifier';
  _ExportDefaultSpecifier: void;
  exported: Node;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

// TODO: Make this correct.
export type ExportNamespaceSpecifier = {
  type: 'ExportNamespaceSpecifier';
  _ExportNamespaceSpecifier: void;
  exported: Node;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

// TODO: Make this correct.
export type ExportSpecifier = {
  type: 'ExportSpecifier';
  _ExportSpecifier: void;
  local: Node;
  exported: Node;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type AnyTypeAnnotation = {
  type: 'AnyTypeAnnotation';
  _AnyTypeAnnotation: void;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type ArrayTypeAnnotation = {
  type: 'ArrayTypeAnnotation';
  _ArrayTypeAnnotation: void;
  elementType: Type;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type BooleanLiteralTypeAnnotation = {
  type: 'BooleanLiteralTypeAnnotation';
  _BooleanLiteralTypeAnnotation: void;
  raw: string;
  value: boolean;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type BooleanTypeAnnotation = {
  type: 'BooleanTypeAnnotation';
  _BooleanTypeAnnotation: void;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type ClassImplements = {
  type: 'ClassImplements';
  _ClassImplements: void;
  id: Identifier;
  typeParameters: ?TypeParameterInstantiation;
  superClass: ?Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type ClassProperty = {
  type: 'ClassProperty';
  _ClassProperty: void;
  computed: boolean;
  key: Node;
  static: boolean;
  typeAnnotation: ?TypeAnnotation;
  value: ?Expression;
  decorators: Array<Decorator>;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type DeclareClass = {
  type: 'DeclareClass';
  _DeclareClass: void;
  body: ObjectTypeAnnotation;
  extends: Array<InterfaceExtends>;
  id: Identifier;
  typeParameters: ?TypeParameterDeclaration;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

// TODO: Make this correct.
export type DeclareFunction = {
  type: 'DeclareFunction';
  _DeclareFunction: void;
  id: Identifier;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type DeclareModule = {
  type: 'DeclareModule';
  _DeclareModule: void;
  body: BlockStatement;
  id: Node;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

// TODO: Make this correct.
export type DeclareVariable = {
  type: 'DeclareVariable';
  _DeclareVariable: void;
  id: Identifier;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type FunctionTypeAnnotation = {
  type: 'FunctionTypeAnnotation';
  _FunctionTypeAnnotation: void;
  params: Array<FunctionTypeParam>;
  rest: ?FunctionTypeParam;
  returnType: Type;
  typeParameters: ?TypeParameterDeclaration;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type FunctionTypeParam = {
  type: 'FunctionTypeParam';
  _FunctionTypeParam: void;
  name: Identifier;
  optional: boolean;
  typeAnnotation: Type;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type GenericTypeAnnotation = {
  type: 'GenericTypeAnnotation';
  _GenericTypeAnnotation: void;
  id: Node;
  typeParameters: ?TypeParameterInstantiation;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type InterfaceExtends = {
  type: 'InterfaceExtends';
  _InterfaceExtends: void;
  id: Identifier;
  typeParameters: ?TypeParameterInstantiation;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type InterfaceDeclaration = {
  type: 'InterfaceDeclaration';
  _InterfaceDeclaration: void;
  body: ObjectTypeAnnotation;
  extends: Array<InterfaceExtends>;
  id: Identifier;
  typeParameters: ?TypeParameterDeclaration;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type IntersectionTypeAnnotation = {
  type: 'IntersectionTypeAnnotation';
  _IntersectionTypeAnnotation: void;
  types: Array<Type>;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type MixedTypeAnnotation = {
  type: 'MixedTypeAnnotation';
  _MixedTypeAnnotation: void;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type NullableTypeAnnotation = {
  type: 'NullableTypeAnnotation';
  _NullableTypeAnnotation: void;
  typeAnnotation: Type;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type NumberLiteralTypeAnnotation = {
  type: 'NumberLiteralTypeAnnotation';
  _NumberLiteralTypeAnnotation: void;
  raw: string;
  value: number;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type NumberTypeAnnotation = {
  type: 'NumberTypeAnnotation';
  _NumberTypeAnnotation: void;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type StringLiteralTypeAnnotation = {
  type: 'StringLiteralTypeAnnotation';
  _StringLiteralTypeAnnotation: void;
  raw: string;
  value: string;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type StringTypeAnnotation = {
  type: 'StringTypeAnnotation';
  _StringTypeAnnotation: void;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type TupleTypeAnnotation = {
  type: 'TupleTypeAnnotation';
  _TupleTypeAnnotation: void;
  types: Array<Type>;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type TypeofTypeAnnotation = {
  type: 'TypeofTypeAnnotation';
  _TypeofTypeAnnotation: void;
  argument: Type;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type TypeAlias = {
  type: 'TypeAlias';
  _TypeAlias: void;
  id: Identifier;
  right: Type;
  typeParameters: ?TypeParameterDeclaration;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type TypeAnnotation = {
  type: 'TypeAnnotation';
  _TypeAnnotation: void;
  typeAnnotation: Type;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type TypeCastExpression = {
  type: 'TypeCastExpression';
  _TypeCastExpression: void;
  expression: Expression;
  typeAnnotation: TypeAnnotation;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type TypeParameterDeclaration = {
  type: 'TypeParameterDeclaration';
  _TypeParameterDeclaration: void;
  params: Array<Identifier>;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type TypeParameterInstantiation = {
  type: 'TypeParameterInstantiation';
  _TypeParameterInstantiation: void;
  params: Array<Type>;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type ObjectTypeAnnotation = {
  type: 'ObjectTypeAnnotation';
  _ObjectTypeAnnotation: void;
  callProperties: Array<ObjectTypeCallProperty>;
  indexers: Array<ObjectTypeIndexer>;
  properties: Array<ObjectTypeProperty>;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type ObjectTypeCallProperty = {
  type: 'ObjectTypeCallProperty';
  _ObjectTypeCallProperty: void;
  static: boolean;
  value: FunctionTypeAnnotation;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type ObjectTypeIndexer = {
  type: 'ObjectTypeIndexer';
  _ObjectTypeIndexer: void;
  id: Identifier;
  key: Type;
  value: Type;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type ObjectTypeProperty = {
  type: 'ObjectTypeProperty';
  _ObjectTypeProperty: void;
  key: Node;
  optional: boolean;
  value: Type;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type QualifiedTypeIdentifier = {
  type: 'QualifiedTypeIdentifier';
  _QualifiedTypeIdentifier: void;
  id: Identifier;
  qualification: Node;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type UnionTypeAnnotation = {
  type: 'UnionTypeAnnotation';
  _UnionTypeAnnotation: void;
  types: Array<Type>;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type VoidTypeAnnotation = {
  type: 'VoidTypeAnnotation';
  _VoidTypeAnnotation: void;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type JSXAttribute = {
  type: 'JSXAttribute';
  _JSXAttribute: void;
  name: Node;
  value: ?Node;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type JSXClosingElement = {
  type: 'JSXClosingElement';
  _JSXClosingElement: void;
  name: Node;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type JSXElement = {
  type: 'JSXElement';
  _JSXElement: void;
  children: Array<Node>;
  closingElement: ?JSXClosingElement;
  openingElement: JSXOpeningElement;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type JSXEmptyExpression = {
  type: 'JSXEmptyExpression';
  _JSXEmptyExpression: void;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type JSXExpressionContainer = {
  type: 'JSXExpressionContainer';
  _JSXExpressionContainer: void;
  expression: Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type JSXIdentifier = {
  type: 'JSXIdentifier';
  _JSXIdentifier: void;
  name: string;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type JSXMemberExpression = {
  type: 'JSXMemberExpression';
  _JSXMemberExpression: void;
  computed: boolean;
  object: Node;
  property: JSXIdentifier;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type JSXNamespacedName = {
  type: 'JSXNamespacedName';
  _JSXNamespacedName: void;
  name: JSXIdentifier;
  namespace: JSXIdentifier;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type JSXOpeningElement = {
  type: 'JSXOpeningElement';
  _JSXOpeningElement: void;
  attributes: Array<Node>;
  name: Array<Node>;
  selfClosing: boolean;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

export type JSXSpreadAttribute = {
  type: 'JSXSpreadAttribute';
  _JSXSpreadAttribute: void;
  argument: Expression;
  end: number;
  innerComments: ?Array<Comment>;
  leadingComments: ?Array<Comment>;
  loc: {
    end: {column: number, line: number},
    start: {column: number, line: number},
  };
  start: number;
  trailingComments: ?Array<Comment>;
};

=====================================output=====================================
/**
 * @flow
 */

"use strict";

/*
 * Flow types for the Babylon AST.
 */

// Abstract types. Something must extend these.

export type Comment =
  | {
      type: "CommentLine",
      _CommentLine: void,
      value: string,
      end: number,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number
    }
  | {
      type: "CommentBlock",
      _CommentBlock: void,
      value: string,
      end: number,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number
    };

export type Declaration =
  | {
      type: "ClassBody",
      _ClassBody: void,
      body: Array<Node>,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "ClassDeclaration",
      _ClassDeclaration: void,
      body: ClassBody,
      id: ?Identifier,
      superClass: ?Expression,
      decorators: any,
      superTypeParameters: any,
      typeParameters: any,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "FunctionDeclaration",
      _FunctionDeclaration: void,
      body: BlockStatement,
      id: Identifier,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>,
      async: boolean,
      defaults: Array<?Expression>,
      expression: boolean,
      generator: boolean,
      params: Array<Pattern>,
      rest: ?Identifier,
      returnType: ?TypeAnnotation,
      typeParameters: ?TypeParameterDeclaration
    }
  | {
      type: "MethodDefinition",
      _MethodDefinition: void,
      computed: boolean,
      key: Node,
      kind: "constructor" | "method" | "get" | "set",
      static: boolean,
      value: FunctionExpression,
      decorators: ?Array<Decorator>,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "VariableDeclaration",
      _VariableDeclaration: void,
      declarations: Array<VariableDeclarator>,
      kind: "var" | "let" | "const",
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "ClassProperty",
      _ClassProperty: void,
      computed: boolean,
      key: Node,
      static: boolean,
      typeAnnotation: ?TypeAnnotation,
      value: ?Expression,
      decorators: Array<Decorator>,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    };

export type Expression =
  | {
      type: "ArrayExpression",
      _ArrayExpression: void,
      elements: Array<?Node>,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "AssignmentExpression",
      _AssignmentExpression: void,
      left: Pattern,
      operator: AssignmentOperator,
      right: Expression,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "AwaitExpression",
      _AwaitExpression: void,
      all: boolean,
      argument: ?Expression,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "BinaryExpression",
      _BinaryExpression: void,
      left: Expression,
      operator: BinaryOperator,
      right: Expression,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "BindExpression",
      _BindExpression: void,
      callee: Node,
      object: Node,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "CallExpression",
      _CallExpression: void,
      arguments: Array<Node>,
      callee: Expression,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "ClassExpression",
      _ClassExpression: void,
      body: ClassBody,
      id: ?Identifier,
      superClass: ?Expression,
      decorators: any,
      superTypeParameters: any,
      typeParameters: any,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "ComprehensionExpression",
      _ComprehensionExpression: void,
      body: Expression,
      blocks: Array<ComprehensionBlock>,
      filter: ?Expression,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "ConditionalExpression",
      _ConditionalExpression: void,
      alternate: Expression,
      consequent: Expression,
      test: Expression,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "DoExpression",
      _DoExpression: void,
      body: Statement,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "FunctionExpression",
      _FunctionExpression: void,
      body: BlockStatement,
      id: ?Identifier,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>,
      async: boolean,
      defaults: Array<?Expression>,
      expression: boolean,
      generator: boolean,
      params: Array<Pattern>,
      rest: ?Identifier,
      returnType: ?TypeAnnotation,
      typeParameters: ?TypeParameterDeclaration
    }
  | {
      type: "Identifier",
      _Identifier: void,
      name: string,
      typeAnnotation: ?TypeAnnotation,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "Literal",
      _Literal: void,
      raw: string,
      regex: ?{ pattern: string, flags: string },
      value: ?(string | boolean | number | RegExp),
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "LogicalExpression",
      _LogicalExpression: void,
      left: Expression,
      operator: LogicalOperator,
      right: Expression,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "MemberExpression",
      _MemberExpression: void,
      computed: boolean,
      object: Expression,
      property: Node,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "NewExpression",
      _NewExpression: void,
      arguments: Array<Node>,
      callee: Expression,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "ObjectExpression",
      _ObjectExpression: void,
      properties: Array<Node>,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "SequenceExpression",
      _SequenceExpression: void,
      expression: Array<Expression>,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "TaggedTemplateExpression",
      _TaggedTemplateExpression: void,
      quasi: TemplateLiteral,
      tag: Expression,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "TemplateLiteral",
      _TemplateLiteral: void,
      expressions: Array<Expression>,
      quasis: Array<TemplateElement>,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "ThisExpression",
      _ThisExpression: void,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "UnaryExpression",
      _UnaryExpression: void,
      argument: Expression,
      operator: UnaryOperator,
      prefix: true,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "UpdateExpression",
      _UpdateExpression: void,
      argument: Expression,
      operator: UpdateOperator,
      prefix: boolean,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "YieldExpression",
      _YieldExpression: void,
      argument: ?Expression,
      delegate: boolean,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "TypeCastExpression",
      _TypeCastExpression: void,
      expression: Expression,
      typeAnnotation: TypeAnnotation,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "JSXElement",
      _JSXElement: void,
      children: Array<Node>,
      closingElement: ?JSXClosingElement,
      openingElement: JSXOpeningElement,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "JSXEmptyExpression",
      _JSXEmptyExpression: void,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "JSXExpressionContainer",
      _JSXExpressionContainer: void,
      expression: Expression,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "JSXMemberExpression",
      _JSXMemberExpression: void,
      computed: boolean,
      object: Node,
      property: JSXIdentifier,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    };

export type Function =
  | {
      type: "ArrowFunctionExpression",
      _ArrowFunctionExpression: void,
      body: Node,
      id: ?Identifier,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>,
      async: boolean,
      defaults: Array<?Expression>,
      expression: boolean,
      generator: boolean,
      params: Array<Pattern>,
      rest: ?Identifier,
      returnType: ?TypeAnnotation,
      typeParameters: ?TypeParameterDeclaration
    }
  | {
      type: "FunctionDeclaration",
      _FunctionDeclaration: void,
      body: BlockStatement,
      id: Identifier,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>,
      async: boolean,
      defaults: Array<?Expression>,
      expression: boolean,
      generator: boolean,
      params: Array<Pattern>,
      rest: ?Identifier,
      returnType: ?TypeAnnotation,
      typeParameters: ?TypeParameterDeclaration
    }
  | {
      type: "FunctionExpression",
      _FunctionExpression: void,
      body: BlockStatement,
      id: ?Identifier,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>,
      async: boolean,
      defaults: Array<?Expression>,
      expression: boolean,
      generator: boolean,
      params: Array<Pattern>,
      rest: ?Identifier,
      returnType: ?TypeAnnotation,
      typeParameters: ?TypeParameterDeclaration
    };

export type Node =
  | {
      type: "ArrayExpression",
      _ArrayExpression: void,
      elements: Array<?Node>,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "ArrayPattern",
      _ArrayPattern: void,
      elements: Array<?Node>,
      typeAnnotation: ?TypeAnnotation,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "ArrowFunctionExpression",
      _ArrowFunctionExpression: void,
      body: Node,
      id: ?Identifier,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>,
      async: boolean,
      defaults: Array<?Expression>,
      expression: boolean,
      generator: boolean,
      params: Array<Pattern>,
      rest: ?Identifier,
      returnType: ?TypeAnnotation,
      typeParameters: ?TypeParameterDeclaration
    }
  | {
      type: "AssignmentExpression",
      _AssignmentExpression: void,
      left: Pattern,
      operator: AssignmentOperator,
      right: Expression,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "AssignmentPattern",
      _AssignmentPattern: void,
      left: Pattern,
      right: Expression,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "AwaitExpression",
      _AwaitExpression: void,
      all: boolean,
      argument: ?Expression,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "BinaryExpression",
      _BinaryExpression: void,
      left: Expression,
      operator: BinaryOperator,
      right: Expression,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "BindExpression",
      _BindExpression: void,
      callee: Node,
      object: Node,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "BlockStatement",
      _BlockStatement: void,
      body: Array<Statement>,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "BreakStatement",
      _BreakStatement: void,
      label: ?Identifier,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "CallExpression",
      _CallExpression: void,
      arguments: Array<Node>,
      callee: Expression,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "CatchClause",
      _CatchClause: void,
      body: BlockStatement,
      param: Pattern,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "ClassBody",
      _ClassBody: void,
      body: Array<Node>,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "ClassDeclaration",
      _ClassDeclaration: void,
      body: ClassBody,
      id: ?Identifier,
      superClass: ?Expression,
      decorators: any,
      superTypeParameters: any,
      typeParameters: any,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "ClassExpression",
      _ClassExpression: void,
      body: ClassBody,
      id: ?Identifier,
      superClass: ?Expression,
      decorators: any,
      superTypeParameters: any,
      typeParameters: any,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "ComprehensionBlock",
      _ComprehensionBlock: void,
      each: boolean,
      left: Pattern,
      right: Expression,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "ComprehensionExpression",
      _ComprehensionExpression: void,
      body: Expression,
      blocks: Array<ComprehensionBlock>,
      filter: ?Expression,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "ConditionalExpression",
      _ConditionalExpression: void,
      alternate: Expression,
      consequent: Expression,
      test: Expression,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "ContinueStatement",
      _ContinueStatement: void,
      label: ?Identifier,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "Decorator",
      _Decorator: void,
      expression: Expression,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "DebuggerStatement",
      _DebuggerStatement: void,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "DoWhileStatement",
      _DoWhileStatement: void,
      body: Statement,
      test: Expression,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "DoExpression",
      _DoExpression: void,
      body: Statement,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "EmptyStatement",
      _EmptyStatement: void,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "ExpressionStatement",
      _ExpressionStatement: void,
      expression: Expression,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "File",
      _File: void,
      program: Program,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "ForInStatement",
      _ForInStatement: void,
      body: Statement,
      left: Node,
      right: Expression,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "ForOfStatement",
      _ForOfStatement: void,
      body: Statement,
      left: Node,
      right: Expression,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "ForStatement",
      _ForStatement: void,
      init: ?Node,
      test: ?Expression,
      update: ?Expression,
      body: Statement,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "FunctionDeclaration",
      _FunctionDeclaration: void,
      body: BlockStatement,
      id: Identifier,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>,
      async: boolean,
      defaults: Array<?Expression>,
      expression: boolean,
      generator: boolean,
      params: Array<Pattern>,
      rest: ?Identifier,
      returnType: ?TypeAnnotation,
      typeParameters: ?TypeParameterDeclaration
    }
  | {
      type: "FunctionExpression",
      _FunctionExpression: void,
      body: BlockStatement,
      id: ?Identifier,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>,
      async: boolean,
      defaults: Array<?Expression>,
      expression: boolean,
      generator: boolean,
      params: Array<Pattern>,
      rest: ?Identifier,
      returnType: ?TypeAnnotation,
      typeParameters: ?TypeParameterDeclaration
    }
  | {
      type: "Identifier",
      _Identifier: void,
      name: string,
      typeAnnotation: ?TypeAnnotation,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "IfStatement",
      _IfStatement: void,
      alternate: ?Statement,
      consequent: Statement,
      test: Expression,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "ImportDefaultSpecifier",
      _ImportDefaultSpecifier: void,
      local: Node,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "ImportNamespaceSpecifier",
      _ImportNamespaceSpecifier: void,
      local: Node,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "ImportDeclaration",
      _ImportDeclaration: void,
      specifiers: Array<Node>,
      source: Literal,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "ImportSpecifier",
      _ImportSpecifier: void,
      imported: Node,
      local: Node,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "LabeledStatement",
      _LabeledStatement: void,
      body: Statement,
      label: Identifier,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "Literal",
      _Literal: void,
      raw: string,
      regex: ?{ pattern: string, flags: string },
      value: ?(string | boolean | number | RegExp),
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "LogicalExpression",
      _LogicalExpression: void,
      left: Expression,
      operator: LogicalOperator,
      right: Expression,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "MemberExpression",
      _MemberExpression: void,
      computed: boolean,
      object: Expression,
      property: Node,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "MetaProperty",
      _MetaProperty: void,
      meta: Node,
      property: Node,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "MethodDefinition",
      _MethodDefinition: void,
      computed: boolean,
      key: Node,
      kind: "constructor" | "method" | "get" | "set",
      static: boolean,
      value: FunctionExpression,
      decorators: ?Array<Decorator>,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "NewExpression",
      _NewExpression: void,
      arguments: Array<Node>,
      callee: Expression,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "Noop",
      _Noop: void,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "ObjectExpression",
      _ObjectExpression: void,
      properties: Array<Node>,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "ObjectPattern",
      _ObjectPattern: void,
      properties: Array<Node>,
      typeAnnotation: ?TypeAnnotation,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "Program",
      _Program: void,
      body: Array<Statement>,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "Property",
      _Property: void,
      computed: boolean,
      key: Node,
      kind: "init" | "get" | "set",
      method: boolean,
      shorthand: boolean,
      value: Node,
      decorators: ?Array<Decorator>,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "RestElement",
      _RestElement: void,
      argument: Pattern,
      typeAnnotation: ?TypeAnnotation,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "ReturnStatement",
      _ReturnStatement: void,
      argument: ?Expression,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "SequenceExpression",
      _SequenceExpression: void,
      expression: Array<Expression>,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "SpreadElement",
      _SpreadElement: void,
      argument: Expression,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "SpreadProperty",
      _SpreadProperty: void,
      argument: Expression,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "Super",
      _Super: void,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "SwitchCase",
      _SwitchCase: void,
      consequent: Array<Statement>,
      test: ?Expression,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "SwitchStatement",
      _SwitchStatement: void,
      cases: Array<SwitchCase>,
      discriminant: Expression,
      lexical: boolean,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "TaggedTemplateExpression",
      _TaggedTemplateExpression: void,
      quasi: TemplateLiteral,
      tag: Expression,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "TemplateElement",
      _TemplateElement: void,
      tail: boolean,
      value: { cooked: string, raw: string },
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "TemplateLiteral",
      _TemplateLiteral: void,
      expressions: Array<Expression>,
      quasis: Array<TemplateElement>,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "ThisExpression",
      _ThisExpression: void,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "ThrowStatement",
      _ThrowStatement: void,
      argument: Expression,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "TryStatement",
      _TryStatement: void,
      block: BlockStatement,
      finalizer: ?BlockStatement,
      guardedHandlers: Array<CatchClause>,
      handler: ?CatchClause,
      handlers: ?Array<CatchClause>,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "UnaryExpression",
      _UnaryExpression: void,
      argument: Expression,
      operator: UnaryOperator,
      prefix: true,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "UpdateExpression",
      _UpdateExpression: void,
      argument: Expression,
      operator: UpdateOperator,
      prefix: boolean,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "VariableDeclaration",
      _VariableDeclaration: void,
      declarations: Array<VariableDeclarator>,
      kind: "var" | "let" | "const",
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "VariableDeclarator",
      _VariableDeclarator: void,
      id: Pattern,
      init: ?Expression,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "WhileStatement",
      _WhileStatement: void,
      body: Statement,
      test: Expression,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "WithStatement",
      _WithStatement: void,
      body: Statement,
      object: Expression,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "YieldExpression",
      _YieldExpression: void,
      argument: ?Expression,
      delegate: boolean,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "ExportAllDeclaration",
      _ExportAllDeclaration: void,
      exported: Node,
      source: Node,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "ExportDefaultDeclaration",
      _ExportDefaultDeclaration: void,
      declaration: Node,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "ExportNamedDeclaration",
      _ExportNamedDeclaration: void,
      declaration: Node,
      source: Literal,
      specifiers: Array<Node>,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "ExportDefaultSpecifier",
      _ExportDefaultSpecifier: void,
      exported: Node,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "ExportNamespaceSpecifier",
      _ExportNamespaceSpecifier: void,
      exported: Node,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "ExportSpecifier",
      _ExportSpecifier: void,
      local: Node,
      exported: Node,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "AnyTypeAnnotation",
      _AnyTypeAnnotation: void,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "ArrayTypeAnnotation",
      _ArrayTypeAnnotation: void,
      elementType: Type,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "BooleanLiteralTypeAnnotation",
      _BooleanLiteralTypeAnnotation: void,
      raw: string,
      value: boolean,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "BooleanTypeAnnotation",
      _BooleanTypeAnnotation: void,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "ClassImplements",
      _ClassImplements: void,
      id: Identifier,
      typeParameters: ?TypeParameterInstantiation,
      superClass: ?Expression,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "ClassProperty",
      _ClassProperty: void,
      computed: boolean,
      key: Node,
      static: boolean,
      typeAnnotation: ?TypeAnnotation,
      value: ?Expression,
      decorators: Array<Decorator>,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "DeclareClass",
      _DeclareClass: void,
      body: ObjectTypeAnnotation,
      extends: Array<InterfaceExtends>,
      id: Identifier,
      typeParameters: ?TypeParameterDeclaration,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "DeclareFunction",
      _DeclareFunction: void,
      id: Identifier,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "DeclareModule",
      _DeclareModule: void,
      body: BlockStatement,
      id: Node,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "DeclareVariable",
      _DeclareVariable: void,
      id: Identifier,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "FunctionTypeAnnotation",
      _FunctionTypeAnnotation: void,
      params: Array<FunctionTypeParam>,
      rest: ?FunctionTypeParam,
      returnType: Type,
      typeParameters: ?TypeParameterDeclaration,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "FunctionTypeParam",
      _FunctionTypeParam: void,
      name: Identifier,
      optional: boolean,
      typeAnnotation: Type,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "GenericTypeAnnotation",
      _GenericTypeAnnotation: void,
      id: Node,
      typeParameters: ?TypeParameterInstantiation,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "InterfaceExtends",
      _InterfaceExtends: void,
      id: Identifier,
      typeParameters: ?TypeParameterInstantiation,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "InterfaceDeclaration",
      _InterfaceDeclaration: void,
      body: ObjectTypeAnnotation,
      extends: Array<InterfaceExtends>,
      id: Identifier,
      typeParameters: ?TypeParameterDeclaration,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "IntersectionTypeAnnotation",
      _IntersectionTypeAnnotation: void,
      types: Array<Type>,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "MixedTypeAnnotation",
      _MixedTypeAnnotation: void,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "NullableTypeAnnotation",
      _NullableTypeAnnotation: void,
      typeAnnotation: Type,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "NumberLiteralTypeAnnotation",
      _NumberLiteralTypeAnnotation: void,
      raw: string,
      value: number,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "NumberTypeAnnotation",
      _NumberTypeAnnotation: void,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "StringLiteralTypeAnnotation",
      _StringLiteralTypeAnnotation: void,
      raw: string,
      value: string,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "StringTypeAnnotation",
      _StringTypeAnnotation: void,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "TupleTypeAnnotation",
      _TupleTypeAnnotation: void,
      types: Array<Type>,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "TypeofTypeAnnotation",
      _TypeofTypeAnnotation: void,
      argument: Type,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "TypeAlias",
      _TypeAlias: void,
      id: Identifier,
      right: Type,
      typeParameters: ?TypeParameterDeclaration,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "TypeAnnotation",
      _TypeAnnotation: void,
      typeAnnotation: Type,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "TypeCastExpression",
      _TypeCastExpression: void,
      expression: Expression,
      typeAnnotation: TypeAnnotation,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "TypeParameterDeclaration",
      _TypeParameterDeclaration: void,
      params: Array<Identifier>,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "TypeParameterInstantiation",
      _TypeParameterInstantiation: void,
      params: Array<Type>,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "ObjectTypeAnnotation",
      _ObjectTypeAnnotation: void,
      callProperties: Array<ObjectTypeCallProperty>,
      indexers: Array<ObjectTypeIndexer>,
      properties: Array<ObjectTypeProperty>,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "ObjectTypeCallProperty",
      _ObjectTypeCallProperty: void,
      static: boolean,
      value: FunctionTypeAnnotation,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "ObjectTypeIndexer",
      _ObjectTypeIndexer: void,
      id: Identifier,
      key: Type,
      value: Type,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "ObjectTypeProperty",
      _ObjectTypeProperty: void,
      key: Node,
      optional: boolean,
      value: Type,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "QualifiedTypeIdentifier",
      _QualifiedTypeIdentifier: void,
      id: Identifier,
      qualification: Node,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "UnionTypeAnnotation",
      _UnionTypeAnnotation: void,
      types: Array<Type>,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "VoidTypeAnnotation",
      _VoidTypeAnnotation: void,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "JSXAttribute",
      _JSXAttribute: void,
      name: Node,
      value: ?Node,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "JSXClosingElement",
      _JSXClosingElement: void,
      name: Node,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "JSXElement",
      _JSXElement: void,
      children: Array<Node>,
      closingElement: ?JSXClosingElement,
      openingElement: JSXOpeningElement,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "JSXEmptyExpression",
      _JSXEmptyExpression: void,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "JSXExpressionContainer",
      _JSXExpressionContainer: void,
      expression: Expression,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "JSXIdentifier",
      _JSXIdentifier: void,
      name: string,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "JSXMemberExpression",
      _JSXMemberExpression: void,
      computed: boolean,
      object: Node,
      property: JSXIdentifier,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "JSXNamespacedName",
      _JSXNamespacedName: void,
      name: JSXIdentifier,
      namespace: JSXIdentifier,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "JSXOpeningElement",
      _JSXOpeningElement: void,
      attributes: Array<Node>,
      name: Array<Node>,
      selfClosing: boolean,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "JSXSpreadAttribute",
      _JSXSpreadAttribute: void,
      argument: Expression,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    };

export type Pattern =
  | {
      type: "ArrayPattern",
      _ArrayPattern: void,
      elements: Array<?Node>,
      typeAnnotation: ?TypeAnnotation,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "AssignmentPattern",
      _AssignmentPattern: void,
      left: Pattern,
      right: Expression,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "Identifier",
      _Identifier: void,
      name: string,
      typeAnnotation: ?TypeAnnotation,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "ObjectPattern",
      _ObjectPattern: void,
      properties: Array<Node>,
      typeAnnotation: ?TypeAnnotation,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "RestElement",
      _RestElement: void,
      argument: Pattern,
      typeAnnotation: ?TypeAnnotation,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    };

export type Statement =
  | {
      type: "BlockStatement",
      _BlockStatement: void,
      body: Array<Statement>,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "BreakStatement",
      _BreakStatement: void,
      label: ?Identifier,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "ContinueStatement",
      _ContinueStatement: void,
      label: ?Identifier,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "DoWhileStatement",
      _DoWhileStatement: void,
      body: Statement,
      test: Expression,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "EmptyStatement",
      _EmptyStatement: void,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "ExpressionStatement",
      _ExpressionStatement: void,
      expression: Expression,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "ForInStatement",
      _ForInStatement: void,
      body: Statement,
      left: Node,
      right: Expression,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "ForOfStatement",
      _ForOfStatement: void,
      body: Statement,
      left: Node,
      right: Expression,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "ForStatement",
      _ForStatement: void,
      init: ?Node,
      test: ?Expression,
      update: ?Expression,
      body: Statement,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "IfStatement",
      _IfStatement: void,
      alternate: ?Statement,
      consequent: Statement,
      test: Expression,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "LabeledStatement",
      _LabeledStatement: void,
      body: Statement,
      label: Identifier,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "ReturnStatement",
      _ReturnStatement: void,
      argument: ?Expression,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "SwitchStatement",
      _SwitchStatement: void,
      cases: Array<SwitchCase>,
      discriminant: Expression,
      lexical: boolean,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "ThrowStatement",
      _ThrowStatement: void,
      argument: Expression,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "TryStatement",
      _TryStatement: void,
      block: BlockStatement,
      finalizer: ?BlockStatement,
      guardedHandlers: Array<CatchClause>,
      handler: ?CatchClause,
      handlers: ?Array<CatchClause>,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "WhileStatement",
      _WhileStatement: void,
      body: Statement,
      test: Expression,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "WithStatement",
      _WithStatement: void,
      body: Statement,
      object: Expression,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "DeclareClass",
      _DeclareClass: void,
      body: ObjectTypeAnnotation,
      extends: Array<InterfaceExtends>,
      id: Identifier,
      typeParameters: ?TypeParameterDeclaration,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "DeclareFunction",
      _DeclareFunction: void,
      id: Identifier,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "DeclareModule",
      _DeclareModule: void,
      body: BlockStatement,
      id: Node,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "DeclareVariable",
      _DeclareVariable: void,
      id: Identifier,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "InterfaceDeclaration",
      _InterfaceDeclaration: void,
      body: ObjectTypeAnnotation,
      extends: Array<InterfaceExtends>,
      id: Identifier,
      typeParameters: ?TypeParameterDeclaration,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "TypeAlias",
      _TypeAlias: void,
      id: Identifier,
      right: Type,
      typeParameters: ?TypeParameterDeclaration,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    };

export type Type =
  | {
      type: "AnyTypeAnnotation",
      _AnyTypeAnnotation: void,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "ArrayTypeAnnotation",
      _ArrayTypeAnnotation: void,
      elementType: Type,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "BooleanLiteralTypeAnnotation",
      _BooleanLiteralTypeAnnotation: void,
      raw: string,
      value: boolean,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "BooleanTypeAnnotation",
      _BooleanTypeAnnotation: void,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "FunctionTypeAnnotation",
      _FunctionTypeAnnotation: void,
      params: Array<FunctionTypeParam>,
      rest: ?FunctionTypeParam,
      returnType: Type,
      typeParameters: ?TypeParameterDeclaration,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "GenericTypeAnnotation",
      _GenericTypeAnnotation: void,
      id: Node,
      typeParameters: ?TypeParameterInstantiation,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "IntersectionTypeAnnotation",
      _IntersectionTypeAnnotation: void,
      types: Array<Type>,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "MixedTypeAnnotation",
      _MixedTypeAnnotation: void,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "NullableTypeAnnotation",
      _NullableTypeAnnotation: void,
      typeAnnotation: Type,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "NumberLiteralTypeAnnotation",
      _NumberLiteralTypeAnnotation: void,
      raw: string,
      value: number,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "NumberTypeAnnotation",
      _NumberTypeAnnotation: void,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "StringLiteralTypeAnnotation",
      _StringLiteralTypeAnnotation: void,
      raw: string,
      value: string,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "StringTypeAnnotation",
      _StringTypeAnnotation: void,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "TupleTypeAnnotation",
      _TupleTypeAnnotation: void,
      types: Array<Type>,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "ObjectTypeAnnotation",
      _ObjectTypeAnnotation: void,
      callProperties: Array<ObjectTypeCallProperty>,
      indexers: Array<ObjectTypeIndexer>,
      properties: Array<ObjectTypeProperty>,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "UnionTypeAnnotation",
      _UnionTypeAnnotation: void,
      types: Array<Type>,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    }
  | {
      type: "VoidTypeAnnotation",
      _VoidTypeAnnotation: void,
      end: number,
      innerComments: ?Array<Comment>,
      leadingComments: ?Array<Comment>,
      loc: {
        end: { column: number, line: number },
        start: { column: number, line: number }
      },
      start: number,
      trailingComments: ?Array<Comment>
    };

// Concrete Types. Nothing can extend these.

export type CommentLine = {
  type: "CommentLine",
  _CommentLine: void,
  value: string,
  end: number,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number
};

export type CommentBlock = {
  type: "CommentBlock",
  _CommentBlock: void,
  value: string,
  end: number,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number
};

// Babel concrete types.

export type ArrayExpression = {
  type: "ArrayExpression",
  _ArrayExpression: void,
  elements: Array<?Node>,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type ArrayPattern = {
  type: "ArrayPattern",
  _ArrayPattern: void,
  elements: Array<?Node>,
  typeAnnotation: ?TypeAnnotation,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type ArrowFunctionExpression = {
  type: "ArrowFunctionExpression",
  _ArrowFunctionExpression: void,
  body: Node,
  id: ?Identifier,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>,
  async: boolean,
  defaults: Array<?Expression>,
  expression: boolean,
  generator: boolean,
  params: Array<Pattern>,
  rest: ?Identifier,
  returnType: ?TypeAnnotation,
  typeParameters: ?TypeParameterDeclaration
};

type AssignmentOperator =
  | "="
  | "+="
  | "-="
  | "*="
  | "/="
  | "%="
  | "<<="
  | ">>="
  | ">>>="
  | "|="
  | "^="
  | "&=";

export type AssignmentExpression = {
  type: "AssignmentExpression",
  _AssignmentExpression: void,
  left: Pattern,
  operator: AssignmentOperator,
  right: Expression,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type AssignmentPattern = {
  type: "AssignmentPattern",
  _AssignmentPattern: void,
  left: Pattern,
  right: Expression,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type AwaitExpression = {
  type: "AwaitExpression",
  _AwaitExpression: void,
  all: boolean,
  argument: ?Expression,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

type BinaryOperator =
  | "=="
  | "!="
  | "==="
  | "!=="
  | "<"
  | "<="
  | ">"
  | ">="
  | "<<"
  | ">>"
  | ">>>"
  | "+"
  | "-"
  | "*"
  | "/"
  | "%"
  | "&"
  | "|"
  | "^"
  | "in"
  | "instanceof"
  | "..";

export type BinaryExpression = {
  type: "BinaryExpression",
  _BinaryExpression: void,
  left: Expression,
  operator: BinaryOperator,
  right: Expression,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

// TODO: What is this?
export type BindExpression = {
  type: "BindExpression",
  _BindExpression: void,
  callee: Node,
  object: Node,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type BlockStatement = {
  type: "BlockStatement",
  _BlockStatement: void,
  body: Array<Statement>,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type BreakStatement = {
  type: "BreakStatement",
  _BreakStatement: void,
  label: ?Identifier,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type CallExpression = {
  type: "CallExpression",
  _CallExpression: void,
  arguments: Array<Node>,
  callee: Expression,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type CatchClause = {
  type: "CatchClause",
  _CatchClause: void,
  body: BlockStatement,
  param: Pattern,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type ClassBody = {
  type: "ClassBody",
  _ClassBody: void,
  body: Array<Node>,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type ClassDeclaration = {
  type: "ClassDeclaration",
  _ClassDeclaration: void,
  body: ClassBody,
  id: ?Identifier,
  superClass: ?Expression,
  decorators: any,
  superTypeParameters: any,
  typeParameters: any,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type ClassExpression = {
  type: "ClassExpression",
  _ClassExpression: void,
  body: ClassBody,
  id: ?Identifier,
  superClass: ?Expression,
  decorators: any,
  superTypeParameters: any,
  typeParameters: any,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type ComprehensionBlock = {
  type: "ComprehensionBlock",
  _ComprehensionBlock: void,
  each: boolean,
  left: Pattern,
  right: Expression,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type ComprehensionExpression = {
  type: "ComprehensionExpression",
  _ComprehensionExpression: void,
  body: Expression,
  blocks: Array<ComprehensionBlock>,
  filter: ?Expression,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type ConditionalExpression = {
  type: "ConditionalExpression",
  _ConditionalExpression: void,
  alternate: Expression,
  consequent: Expression,
  test: Expression,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type ContinueStatement = {
  type: "ContinueStatement",
  _ContinueStatement: void,
  label: ?Identifier,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

// TODO: Make this correct.
export type Decorator = {
  type: "Decorator",
  _Decorator: void,
  expression: Expression,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type DebuggerStatement = {
  type: "DebuggerStatement",
  _DebuggerStatement: void,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type DoWhileStatement = {
  type: "DoWhileStatement",
  _DoWhileStatement: void,
  body: Statement,
  test: Expression,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

// TODO: Make this correct.
export type DoExpression = {
  type: "DoExpression",
  _DoExpression: void,
  body: Statement,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type EmptyStatement = {
  type: "EmptyStatement",
  _EmptyStatement: void,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type ExpressionStatement = {
  type: "ExpressionStatement",
  _ExpressionStatement: void,
  expression: Expression,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type File = {
  type: "File",
  _File: void,
  program: Program,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type ForInStatement = {
  type: "ForInStatement",
  _ForInStatement: void,
  body: Statement,
  left: Node,
  right: Expression,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

// TODO: Make this correct.
export type ForOfStatement = {
  type: "ForOfStatement",
  _ForOfStatement: void,
  body: Statement,
  left: Node,
  right: Expression,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type ForStatement = {
  type: "ForStatement",
  _ForStatement: void,
  init: ?Node,
  test: ?Expression,
  update: ?Expression,
  body: Statement,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type FunctionDeclaration = {
  type: "FunctionDeclaration",
  _FunctionDeclaration: void,
  body: BlockStatement,
  id: Identifier,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>,
  async: boolean,
  defaults: Array<?Expression>,
  expression: boolean,
  generator: boolean,
  params: Array<Pattern>,
  rest: ?Identifier,
  returnType: ?TypeAnnotation,
  typeParameters: ?TypeParameterDeclaration
};

export type FunctionExpression = {
  type: "FunctionExpression",
  _FunctionExpression: void,
  body: BlockStatement,
  id: ?Identifier,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>,
  async: boolean,
  defaults: Array<?Expression>,
  expression: boolean,
  generator: boolean,
  params: Array<Pattern>,
  rest: ?Identifier,
  returnType: ?TypeAnnotation,
  typeParameters: ?TypeParameterDeclaration
};

export type Identifier = {
  type: "Identifier",
  _Identifier: void,
  name: string,
  typeAnnotation: ?TypeAnnotation,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type IfStatement = {
  type: "IfStatement",
  _IfStatement: void,
  alternate: ?Statement,
  consequent: Statement,
  test: Expression,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

// TODO: Make this correct.
export type ImportDefaultSpecifier = {
  type: "ImportDefaultSpecifier",
  _ImportDefaultSpecifier: void,
  local: Node,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

// TODO: Make this correct.
export type ImportNamespaceSpecifier = {
  type: "ImportNamespaceSpecifier",
  _ImportNamespaceSpecifier: void,
  local: Node,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

// TODO: Make this correct.
export type ImportDeclaration = {
  type: "ImportDeclaration",
  _ImportDeclaration: void,
  specifiers: Array<Node>,
  source: Literal,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

// TODO: Make this correct.
export type ImportSpecifier = {
  type: "ImportSpecifier",
  _ImportSpecifier: void,
  imported: Node,
  local: Node,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type LabeledStatement = {
  type: "LabeledStatement",
  _LabeledStatement: void,
  body: Statement,
  label: Identifier,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type Literal = {
  type: "Literal",
  _Literal: void,
  raw: string,
  regex: ?{ pattern: string, flags: string },
  value: ?(string | boolean | number | RegExp),
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

type LogicalOperator = "||" | "&&";

export type LogicalExpression = {
  type: "LogicalExpression",
  _LogicalExpression: void,
  left: Expression,
  operator: LogicalOperator,
  right: Expression,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type MemberExpression = {
  type: "MemberExpression",
  _MemberExpression: void,
  computed: boolean,
  object: Expression,
  property: Node,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

// TODO: Make this correct.
export type MetaProperty = {
  type: "MetaProperty",
  _MetaProperty: void,
  meta: Node,
  property: Node,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type MethodDefinition = {
  type: "MethodDefinition",
  _MethodDefinition: void,
  computed: boolean,
  key: Node,
  kind: "constructor" | "method" | "get" | "set",
  static: boolean,
  value: FunctionExpression,
  decorators: ?Array<Decorator>,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type NewExpression = {
  type: "NewExpression",
  _NewExpression: void,
  arguments: Array<Node>,
  callee: Expression,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type Noop = {
  type: "Noop",
  _Noop: void,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type ObjectExpression = {
  type: "ObjectExpression",
  _ObjectExpression: void,
  properties: Array<Node>,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type ObjectPattern = {
  type: "ObjectPattern",
  _ObjectPattern: void,
  properties: Array<Node>,
  typeAnnotation: ?TypeAnnotation,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type Program = {
  type: "Program",
  _Program: void,
  body: Array<Statement>,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type Property = {
  type: "Property",
  _Property: void,
  computed: boolean,
  key: Node,
  kind: "init" | "get" | "set",
  method: boolean,
  shorthand: boolean,
  value: Node,
  decorators: ?Array<Decorator>,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type RestElement = {
  type: "RestElement",
  _RestElement: void,
  argument: Pattern,
  typeAnnotation: ?TypeAnnotation,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type ReturnStatement = {
  type: "ReturnStatement",
  _ReturnStatement: void,
  argument: ?Expression,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type SequenceExpression = {
  type: "SequenceExpression",
  _SequenceExpression: void,
  expression: Array<Expression>,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type SpreadElement = {
  type: "SpreadElement",
  _SpreadElement: void,
  argument: Expression,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type SpreadProperty = {
  type: "SpreadProperty",
  _SpreadProperty: void,
  argument: Expression,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type Super = {
  type: "Super",
  _Super: void,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type SwitchCase = {
  type: "SwitchCase",
  _SwitchCase: void,
  consequent: Array<Statement>,
  test: ?Expression,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type SwitchStatement = {
  type: "SwitchStatement",
  _SwitchStatement: void,
  cases: Array<SwitchCase>,
  discriminant: Expression,
  lexical: boolean,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type TaggedTemplateExpression = {
  type: "TaggedTemplateExpression",
  _TaggedTemplateExpression: void,
  quasi: TemplateLiteral,
  tag: Expression,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type TemplateElement = {
  type: "TemplateElement",
  _TemplateElement: void,
  tail: boolean,
  value: { cooked: string, raw: string },
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type TemplateLiteral = {
  type: "TemplateLiteral",
  _TemplateLiteral: void,
  expressions: Array<Expression>,
  quasis: Array<TemplateElement>,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type ThisExpression = {
  type: "ThisExpression",
  _ThisExpression: void,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type ThrowStatement = {
  type: "ThrowStatement",
  _ThrowStatement: void,
  argument: Expression,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type TryStatement = {
  type: "TryStatement",
  _TryStatement: void,
  block: BlockStatement,
  finalizer: ?BlockStatement,
  guardedHandlers: Array<CatchClause>,
  handler: ?CatchClause,
  handlers: ?Array<CatchClause>,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

type UnaryOperator = "-" | "+" | "!" | "~" | "typeof" | "void" | "delete";

export type UnaryExpression = {
  type: "UnaryExpression",
  _UnaryExpression: void,
  argument: Expression,
  operator: UnaryOperator,
  prefix: true,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

type UpdateOperator = "++" | "--";

export type UpdateExpression = {
  type: "UpdateExpression",
  _UpdateExpression: void,
  argument: Expression,
  operator: UpdateOperator,
  prefix: boolean,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type VariableDeclaration = {
  type: "VariableDeclaration",
  _VariableDeclaration: void,
  declarations: Array<VariableDeclarator>,
  kind: "var" | "let" | "const",
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type VariableDeclarator = {
  type: "VariableDeclarator",
  _VariableDeclarator: void,
  id: Pattern,
  init: ?Expression,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type WhileStatement = {
  type: "WhileStatement",
  _WhileStatement: void,
  body: Statement,
  test: Expression,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type WithStatement = {
  type: "WithStatement",
  _WithStatement: void,
  body: Statement,
  object: Expression,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type YieldExpression = {
  type: "YieldExpression",
  _YieldExpression: void,
  argument: ?Expression,
  delegate: boolean,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

// TODO: Make this correct.
export type ExportAllDeclaration = {
  type: "ExportAllDeclaration",
  _ExportAllDeclaration: void,
  exported: Node,
  source: Node,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

// TODO: Make this correct.
export type ExportDefaultDeclaration = {
  type: "ExportDefaultDeclaration",
  _ExportDefaultDeclaration: void,
  declaration: Node,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

// TODO: Make this correct.
export type ExportNamedDeclaration = {
  type: "ExportNamedDeclaration",
  _ExportNamedDeclaration: void,
  declaration: Node,
  source: Literal,
  specifiers: Array<Node>,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

// TODO: Make this correct.
export type ExportDefaultSpecifier = {
  type: "ExportDefaultSpecifier",
  _ExportDefaultSpecifier: void,
  exported: Node,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

// TODO: Make this correct.
export type ExportNamespaceSpecifier = {
  type: "ExportNamespaceSpecifier",
  _ExportNamespaceSpecifier: void,
  exported: Node,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

// TODO: Make this correct.
export type ExportSpecifier = {
  type: "ExportSpecifier",
  _ExportSpecifier: void,
  local: Node,
  exported: Node,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type AnyTypeAnnotation = {
  type: "AnyTypeAnnotation",
  _AnyTypeAnnotation: void,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type ArrayTypeAnnotation = {
  type: "ArrayTypeAnnotation",
  _ArrayTypeAnnotation: void,
  elementType: Type,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type BooleanLiteralTypeAnnotation = {
  type: "BooleanLiteralTypeAnnotation",
  _BooleanLiteralTypeAnnotation: void,
  raw: string,
  value: boolean,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type BooleanTypeAnnotation = {
  type: "BooleanTypeAnnotation",
  _BooleanTypeAnnotation: void,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type ClassImplements = {
  type: "ClassImplements",
  _ClassImplements: void,
  id: Identifier,
  typeParameters: ?TypeParameterInstantiation,
  superClass: ?Expression,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type ClassProperty = {
  type: "ClassProperty",
  _ClassProperty: void,
  computed: boolean,
  key: Node,
  static: boolean,
  typeAnnotation: ?TypeAnnotation,
  value: ?Expression,
  decorators: Array<Decorator>,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type DeclareClass = {
  type: "DeclareClass",
  _DeclareClass: void,
  body: ObjectTypeAnnotation,
  extends: Array<InterfaceExtends>,
  id: Identifier,
  typeParameters: ?TypeParameterDeclaration,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

// TODO: Make this correct.
export type DeclareFunction = {
  type: "DeclareFunction",
  _DeclareFunction: void,
  id: Identifier,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type DeclareModule = {
  type: "DeclareModule",
  _DeclareModule: void,
  body: BlockStatement,
  id: Node,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

// TODO: Make this correct.
export type DeclareVariable = {
  type: "DeclareVariable",
  _DeclareVariable: void,
  id: Identifier,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type FunctionTypeAnnotation = {
  type: "FunctionTypeAnnotation",
  _FunctionTypeAnnotation: void,
  params: Array<FunctionTypeParam>,
  rest: ?FunctionTypeParam,
  returnType: Type,
  typeParameters: ?TypeParameterDeclaration,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type FunctionTypeParam = {
  type: "FunctionTypeParam",
  _FunctionTypeParam: void,
  name: Identifier,
  optional: boolean,
  typeAnnotation: Type,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type GenericTypeAnnotation = {
  type: "GenericTypeAnnotation",
  _GenericTypeAnnotation: void,
  id: Node,
  typeParameters: ?TypeParameterInstantiation,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type InterfaceExtends = {
  type: "InterfaceExtends",
  _InterfaceExtends: void,
  id: Identifier,
  typeParameters: ?TypeParameterInstantiation,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type InterfaceDeclaration = {
  type: "InterfaceDeclaration",
  _InterfaceDeclaration: void,
  body: ObjectTypeAnnotation,
  extends: Array<InterfaceExtends>,
  id: Identifier,
  typeParameters: ?TypeParameterDeclaration,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type IntersectionTypeAnnotation = {
  type: "IntersectionTypeAnnotation",
  _IntersectionTypeAnnotation: void,
  types: Array<Type>,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type MixedTypeAnnotation = {
  type: "MixedTypeAnnotation",
  _MixedTypeAnnotation: void,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type NullableTypeAnnotation = {
  type: "NullableTypeAnnotation",
  _NullableTypeAnnotation: void,
  typeAnnotation: Type,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type NumberLiteralTypeAnnotation = {
  type: "NumberLiteralTypeAnnotation",
  _NumberLiteralTypeAnnotation: void,
  raw: string,
  value: number,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type NumberTypeAnnotation = {
  type: "NumberTypeAnnotation",
  _NumberTypeAnnotation: void,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type StringLiteralTypeAnnotation = {
  type: "StringLiteralTypeAnnotation",
  _StringLiteralTypeAnnotation: void,
  raw: string,
  value: string,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type StringTypeAnnotation = {
  type: "StringTypeAnnotation",
  _StringTypeAnnotation: void,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type TupleTypeAnnotation = {
  type: "TupleTypeAnnotation",
  _TupleTypeAnnotation: void,
  types: Array<Type>,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type TypeofTypeAnnotation = {
  type: "TypeofTypeAnnotation",
  _TypeofTypeAnnotation: void,
  argument: Type,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type TypeAlias = {
  type: "TypeAlias",
  _TypeAlias: void,
  id: Identifier,
  right: Type,
  typeParameters: ?TypeParameterDeclaration,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type TypeAnnotation = {
  type: "TypeAnnotation",
  _TypeAnnotation: void,
  typeAnnotation: Type,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type TypeCastExpression = {
  type: "TypeCastExpression",
  _TypeCastExpression: void,
  expression: Expression,
  typeAnnotation: TypeAnnotation,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type TypeParameterDeclaration = {
  type: "TypeParameterDeclaration",
  _TypeParameterDeclaration: void,
  params: Array<Identifier>,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type TypeParameterInstantiation = {
  type: "TypeParameterInstantiation",
  _TypeParameterInstantiation: void,
  params: Array<Type>,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type ObjectTypeAnnotation = {
  type: "ObjectTypeAnnotation",
  _ObjectTypeAnnotation: void,
  callProperties: Array<ObjectTypeCallProperty>,
  indexers: Array<ObjectTypeIndexer>,
  properties: Array<ObjectTypeProperty>,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type ObjectTypeCallProperty = {
  type: "ObjectTypeCallProperty",
  _ObjectTypeCallProperty: void,
  static: boolean,
  value: FunctionTypeAnnotation,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type ObjectTypeIndexer = {
  type: "ObjectTypeIndexer",
  _ObjectTypeIndexer: void,
  id: Identifier,
  key: Type,
  value: Type,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type ObjectTypeProperty = {
  type: "ObjectTypeProperty",
  _ObjectTypeProperty: void,
  key: Node,
  optional: boolean,
  value: Type,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type QualifiedTypeIdentifier = {
  type: "QualifiedTypeIdentifier",
  _QualifiedTypeIdentifier: void,
  id: Identifier,
  qualification: Node,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type UnionTypeAnnotation = {
  type: "UnionTypeAnnotation",
  _UnionTypeAnnotation: void,
  types: Array<Type>,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type VoidTypeAnnotation = {
  type: "VoidTypeAnnotation",
  _VoidTypeAnnotation: void,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type JSXAttribute = {
  type: "JSXAttribute",
  _JSXAttribute: void,
  name: Node,
  value: ?Node,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type JSXClosingElement = {
  type: "JSXClosingElement",
  _JSXClosingElement: void,
  name: Node,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type JSXElement = {
  type: "JSXElement",
  _JSXElement: void,
  children: Array<Node>,
  closingElement: ?JSXClosingElement,
  openingElement: JSXOpeningElement,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type JSXEmptyExpression = {
  type: "JSXEmptyExpression",
  _JSXEmptyExpression: void,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type JSXExpressionContainer = {
  type: "JSXExpressionContainer",
  _JSXExpressionContainer: void,
  expression: Expression,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type JSXIdentifier = {
  type: "JSXIdentifier",
  _JSXIdentifier: void,
  name: string,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type JSXMemberExpression = {
  type: "JSXMemberExpression",
  _JSXMemberExpression: void,
  computed: boolean,
  object: Node,
  property: JSXIdentifier,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type JSXNamespacedName = {
  type: "JSXNamespacedName",
  _JSXNamespacedName: void,
  name: JSXIdentifier,
  namespace: JSXIdentifier,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type JSXOpeningElement = {
  type: "JSXOpeningElement",
  _JSXOpeningElement: void,
  attributes: Array<Node>,
  name: Array<Node>,
  selfClosing: boolean,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

export type JSXSpreadAttribute = {
  type: "JSXSpreadAttribute",
  _JSXSpreadAttribute: void,
  argument: Expression,
  end: number,
  innerComments: ?Array<Comment>,
  leadingComments: ?Array<Comment>,
  loc: {
    end: { column: number, line: number },
    start: { column: number, line: number }
  },
  start: number,
  trailingComments: ?Array<Comment>
};

================================================================================
`;
