“use strict”;

var _utils = _interopRequireWildcard(require(“./utils”));

function _getRequireWildcardCache() { if (typeof WeakMap !== “function”) return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; if (obj != null) { var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj = obj; } } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }

const defineInterfaceishType = (name, typeParameterType = “TypeParameterDeclaration”) => {

(0, _utils.default)(name, {
  builder: ["id", "typeParameters", "extends", "body"],
  visitor: ["id", "typeParameters", "extends", "mixins", "implements", "body"],
  aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"],
  fields: {
    id: (0, _utils.validateType)("Identifier"),
    typeParameters: (0, _utils.validateOptionalType)(typeParameterType),
    extends: (0, _utils.validateOptional)((0, _utils.arrayOfType)("InterfaceExtends")),
    mixins: (0, _utils.validateOptional)((0, _utils.arrayOfType)("InterfaceExtends")),
    implements: (0, _utils.validateOptional)((0, _utils.arrayOfType)("ClassImplements")),
    body: (0, _utils.validateType)("ObjectTypeAnnotation")
  }
});

};

(0, _utils.default)(“AnyTypeAnnotation”, {

aliases: ["Flow", "FlowType", "FlowBaseAnnotation"]

}); (0, _utils.default)(“ArrayTypeAnnotation”, {

visitor: ["elementType"],
aliases: ["Flow", "FlowType"],
fields: {
  elementType: (0, _utils.validateType)("FlowType")
}

}); (0, _utils.default)(“BooleanTypeAnnotation”, {

aliases: ["Flow", "FlowType", "FlowBaseAnnotation"]

}); (0, _utils.default)(“BooleanLiteralTypeAnnotation”, {

builder: ["value"],
aliases: ["Flow", "FlowType"],
fields: {
  value: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
}

}); (0, _utils.default)(“NullLiteralTypeAnnotation”, {

aliases: ["Flow", "FlowType", "FlowBaseAnnotation"]

}); (0, _utils.default)(“ClassImplements”, {

visitor: ["id", "typeParameters"],
aliases: ["Flow"],
fields: {
  id: (0, _utils.validateType)("Identifier"),
  typeParameters: (0, _utils.validateOptionalType)("TypeParameterInstantiation")
}

}); defineInterfaceishType(“DeclareClass”); (0, _utils.default)(“DeclareFunction”, {

visitor: ["id"],
aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"],
fields: {
  id: (0, _utils.validateType)("Identifier"),
  predicate: (0, _utils.validateOptionalType)("DeclaredPredicate")
}

}); defineInterfaceishType(“DeclareInterface”); (0, _utils.default)(“DeclareModule”, {

builder: ["id", "body", "kind"],
visitor: ["id", "body"],
aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"],
fields: {
  id: (0, _utils.validateType)(["Identifier", "StringLiteral"]),
  body: (0, _utils.validateType)("BlockStatement"),
  kind: (0, _utils.validateOptional)((0, _utils.assertOneOf)("CommonJS", "ES"))
}

}); (0, _utils.default)(“DeclareModuleExports”, {

visitor: ["typeAnnotation"],
aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"],
fields: {
  typeAnnotation: (0, _utils.validateType)("TypeAnnotation")
}

}); (0, _utils.default)(“DeclareTypeAlias”, {

visitor: ["id", "typeParameters", "right"],
aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"],
fields: {
  id: (0, _utils.validateType)("Identifier"),
  typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"),
  right: (0, _utils.validateType)("FlowType")
}

}); (0, _utils.default)(“DeclareOpaqueType”, {

visitor: ["id", "typeParameters", "supertype"],
aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"],
fields: {
  id: (0, _utils.validateType)("Identifier"),
  typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"),
  supertype: (0, _utils.validateOptionalType)("FlowType")
}

}); (0, _utils.default)(“DeclareVariable”, {

visitor: ["id"],
aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"],
fields: {
  id: (0, _utils.validateType)("Identifier")
}

}); (0, _utils.default)(“DeclareExportDeclaration”, {

visitor: ["declaration", "specifiers", "source"],
aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"],
fields: {
  declaration: (0, _utils.validateOptionalType)("Flow"),
  specifiers: (0, _utils.validateOptional)((0, _utils.arrayOfType)(["ExportSpecifier", "ExportNamespaceSpecifier"])),
  source: (0, _utils.validateOptionalType)("StringLiteral"),
  default: (0, _utils.validateOptional)((0, _utils.assertValueType)("boolean"))
}

}); (0, _utils.default)(“DeclareExportAllDeclaration”, {

visitor: ["source"],
aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"],
fields: {
  source: (0, _utils.validateType)("StringLiteral"),
  exportKind: (0, _utils.validateOptional)((0, _utils.assertOneOf)("type", "value"))
}

}); (0, _utils.default)(“DeclaredPredicate”, {

visitor: ["value"],
aliases: ["Flow", "FlowPredicate"],
fields: {
  value: (0, _utils.validateType)("Flow")
}

}); (0, _utils.default)(“ExistsTypeAnnotation”, {

aliases: ["Flow", "FlowType"]

}); (0, _utils.default)(“FunctionTypeAnnotation”, {

visitor: ["typeParameters", "params", "rest", "returnType"],
aliases: ["Flow", "FlowType"],
fields: {
  typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"),
  params: (0, _utils.validate)((0, _utils.arrayOfType)("FunctionTypeParam")),
  rest: (0, _utils.validateOptionalType)("FunctionTypeParam"),
  returnType: (0, _utils.validateType)("FlowType")
}

}); (0, _utils.default)(“FunctionTypeParam”, {

visitor: ["name", "typeAnnotation"],
aliases: ["Flow"],
fields: {
  name: (0, _utils.validateOptionalType)("Identifier"),
  typeAnnotation: (0, _utils.validateType)("FlowType"),
  optional: (0, _utils.validateOptional)((0, _utils.assertValueType)("boolean"))
}

}); (0, _utils.default)(“GenericTypeAnnotation”, {

visitor: ["id", "typeParameters"],
aliases: ["Flow", "FlowType"],
fields: {
  id: (0, _utils.validateType)(["Identifier", "QualifiedTypeIdentifier"]),
  typeParameters: (0, _utils.validateOptionalType)("TypeParameterInstantiation")
}

}); (0, _utils.default)(“InferredPredicate”, {

aliases: ["Flow", "FlowPredicate"]

}); (0, _utils.default)(“InterfaceExtends”, {

visitor: ["id", "typeParameters"],
aliases: ["Flow"],
fields: {
  id: (0, _utils.validateType)(["Identifier", "QualifiedTypeIdentifier"]),
  typeParameters: (0, _utils.validateOptionalType)("TypeParameterInstantiation")
}

}); defineInterfaceishType(“InterfaceDeclaration”); (0, _utils.default)(“InterfaceTypeAnnotation”, {

visitor: ["extends", "body"],
aliases: ["Flow", "FlowType"],
fields: {
  extends: (0, _utils.validateOptional)((0, _utils.arrayOfType)("InterfaceExtends")),
  body: (0, _utils.validateType)("ObjectTypeAnnotation")
}

}); (0, _utils.default)(“IntersectionTypeAnnotation”, {

visitor: ["types"],
aliases: ["Flow", "FlowType"],
fields: {
  types: (0, _utils.validate)((0, _utils.arrayOfType)("FlowType"))
}

}); (0, _utils.default)(“MixedTypeAnnotation”, {

aliases: ["Flow", "FlowType", "FlowBaseAnnotation"]

}); (0, _utils.default)(“EmptyTypeAnnotation”, {

aliases: ["Flow", "FlowType", "FlowBaseAnnotation"]

}); (0, _utils.default)(“NullableTypeAnnotation”, {

visitor: ["typeAnnotation"],
aliases: ["Flow", "FlowType"],
fields: {
  typeAnnotation: (0, _utils.validateType)("FlowType")
}

}); (0, _utils.default)(“NumberLiteralTypeAnnotation”, {

builder: ["value"],
aliases: ["Flow", "FlowType"],
fields: {
  value: (0, _utils.validate)((0, _utils.assertValueType)("number"))
}

}); (0, _utils.default)(“NumberTypeAnnotation”, {

aliases: ["Flow", "FlowType", "FlowBaseAnnotation"]

}); (0, _utils.default)(“ObjectTypeAnnotation”, {

visitor: ["properties", "indexers", "callProperties", "internalSlots"],
aliases: ["Flow", "FlowType"],
builder: ["properties", "indexers", "callProperties", "internalSlots", "exact"],
fields: {
  properties: (0, _utils.validate)((0, _utils.arrayOfType)(["ObjectTypeProperty", "ObjectTypeSpreadProperty"])),
  indexers: (0, _utils.validateOptional)((0, _utils.arrayOfType)("ObjectTypeIndexer")),
  callProperties: (0, _utils.validateOptional)((0, _utils.arrayOfType)("ObjectTypeCallProperty")),
  internalSlots: (0, _utils.validateOptional)((0, _utils.arrayOfType)("ObjectTypeInternalSlot")),
  exact: {
    validate: (0, _utils.assertValueType)("boolean"),
    default: false
  },
  inexact: (0, _utils.validateOptional)((0, _utils.assertValueType)("boolean"))
}

}); (0, _utils.default)(“ObjectTypeInternalSlot”, {

visitor: ["id", "value", "optional", "static", "method"],
aliases: ["Flow", "UserWhitespacable"],
fields: {
  id: (0, _utils.validateType)("Identifier"),
  value: (0, _utils.validateType)("FlowType"),
  optional: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
  static: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
  method: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
}

}); (0, _utils.default)(“ObjectTypeCallProperty”, {

visitor: ["value"],
aliases: ["Flow", "UserWhitespacable"],
fields: {
  value: (0, _utils.validateType)("FlowType"),
  static: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
}

}); (0, _utils.default)(“ObjectTypeIndexer”, {

visitor: ["id", "key", "value", "variance"],
aliases: ["Flow", "UserWhitespacable"],
fields: {
  id: (0, _utils.validateOptionalType)("Identifier"),
  key: (0, _utils.validateType)("FlowType"),
  value: (0, _utils.validateType)("FlowType"),
  static: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
  variance: (0, _utils.validateOptionalType)("Variance")
}

}); (0, _utils.default)(“ObjectTypeProperty”, {

visitor: ["key", "value", "variance"],
aliases: ["Flow", "UserWhitespacable"],
fields: {
  key: (0, _utils.validateType)(["Identifier", "StringLiteral"]),
  value: (0, _utils.validateType)("FlowType"),
  kind: (0, _utils.validate)((0, _utils.assertOneOf)("init", "get", "set")),
  static: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
  proto: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
  optional: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
  variance: (0, _utils.validateOptionalType)("Variance")
}

}); (0, _utils.default)(“ObjectTypeSpreadProperty”, {

visitor: ["argument"],
aliases: ["Flow", "UserWhitespacable"],
fields: {
  argument: (0, _utils.validateType)("FlowType")
}

}); (0, _utils.default)(“OpaqueType”, {

visitor: ["id", "typeParameters", "supertype", "impltype"],
aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"],
fields: {
  id: (0, _utils.validateType)("Identifier"),
  typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"),
  supertype: (0, _utils.validateOptionalType)("FlowType"),
  impltype: (0, _utils.validateType)("FlowType")
}

}); (0, _utils.default)(“QualifiedTypeIdentifier”, {

visitor: ["id", "qualification"],
aliases: ["Flow"],
fields: {
  id: (0, _utils.validateType)("Identifier"),
  qualification: (0, _utils.validateType)(["Identifier", "QualifiedTypeIdentifier"])
}

}); (0, _utils.default)(“StringLiteralTypeAnnotation”, {

builder: ["value"],
aliases: ["Flow", "FlowType"],
fields: {
  value: (0, _utils.validate)((0, _utils.assertValueType)("string"))
}

}); (0, _utils.default)(“StringTypeAnnotation”, {

aliases: ["Flow", "FlowType", "FlowBaseAnnotation"]

}); (0, _utils.default)(“ThisTypeAnnotation”, {

aliases: ["Flow", "FlowType", "FlowBaseAnnotation"]

}); (0, _utils.default)(“TupleTypeAnnotation”, {

visitor: ["types"],
aliases: ["Flow", "FlowType"],
fields: {
  types: (0, _utils.validate)((0, _utils.arrayOfType)("FlowType"))
}

}); (0, _utils.default)(“TypeofTypeAnnotation”, {

visitor: ["argument"],
aliases: ["Flow", "FlowType"],
fields: {
  argument: (0, _utils.validateType)("FlowType")
}

}); (0, _utils.default)(“TypeAlias”, {

visitor: ["id", "typeParameters", "right"],
aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"],
fields: {
  id: (0, _utils.validateType)("Identifier"),
  typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"),
  right: (0, _utils.validateType)("FlowType")
}

}); (0, _utils.default)(“TypeAnnotation”, {

aliases: ["Flow"],
visitor: ["typeAnnotation"],
fields: {
  typeAnnotation: (0, _utils.validateType)("FlowType")
}

}); (0, _utils.default)(“TypeCastExpression”, {

visitor: ["expression", "typeAnnotation"],
aliases: ["Flow", "ExpressionWrapper", "Expression"],
fields: {
  expression: (0, _utils.validateType)("Expression"),
  typeAnnotation: (0, _utils.validateType)("TypeAnnotation")
}

}); (0, _utils.default)(“TypeParameter”, {

aliases: ["Flow"],
visitor: ["bound", "default", "variance"],
fields: {
  name: (0, _utils.validate)((0, _utils.assertValueType)("string")),
  bound: (0, _utils.validateOptionalType)("TypeAnnotation"),
  default: (0, _utils.validateOptionalType)("FlowType"),
  variance: (0, _utils.validateOptionalType)("Variance")
}

}); (0, _utils.default)(“TypeParameterDeclaration”, {

aliases: ["Flow"],
visitor: ["params"],
fields: {
  params: (0, _utils.validate)((0, _utils.arrayOfType)("TypeParameter"))
}

}); (0, _utils.default)(“TypeParameterInstantiation”, {

aliases: ["Flow"],
visitor: ["params"],
fields: {
  params: (0, _utils.validate)((0, _utils.arrayOfType)("FlowType"))
}

}); (0, _utils.default)(“UnionTypeAnnotation”, {

visitor: ["types"],
aliases: ["Flow", "FlowType"],
fields: {
  types: (0, _utils.validate)((0, _utils.arrayOfType)("FlowType"))
}

}); (0, _utils.default)(“Variance”, {

aliases: ["Flow"],
builder: ["kind"],
fields: {
  kind: (0, _utils.validate)((0, _utils.assertOneOf)("minus", "plus"))
}

}); (0, _utils.default)(“VoidTypeAnnotation”, {

aliases: ["Flow", "FlowType", "FlowBaseAnnotation"]

});