“use strict”;

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

var _core = require(“./core”);

var _es = require(“./es2015”);

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 bool = (0, _utils.assertValueType)(“boolean”); const tSFunctionTypeAnnotationCommon = {

returnType: {
  validate: (0, _utils.assertNodeType)("TSTypeAnnotation", "Noop"),
  optional: true
},
typeParameters: {
  validate: (0, _utils.assertNodeType)("TSTypeParameterDeclaration", "Noop"),
  optional: true
}

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

aliases: ["LVal"],
visitor: ["parameter"],
fields: {
  accessibility: {
    validate: (0, _utils.assertOneOf)("public", "private", "protected"),
    optional: true
  },
  readonly: {
    validate: (0, _utils.assertValueType)("boolean"),
    optional: true
  },
  parameter: {
    validate: (0, _utils.assertNodeType)("Identifier", "AssignmentPattern")
  }
}

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

aliases: ["Statement", "Declaration"],
visitor: ["id", "typeParameters", "params", "returnType"],
fields: Object.assign({}, _core.functionDeclarationCommon, {}, tSFunctionTypeAnnotationCommon)

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

visitor: ["decorators", "key", "typeParameters", "params", "returnType"],
fields: Object.assign({}, _es.classMethodOrDeclareMethodCommon, {}, tSFunctionTypeAnnotationCommon)

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

aliases: ["TSEntityName"],
visitor: ["left", "right"],
fields: {
  left: (0, _utils.validateType)("TSEntityName"),
  right: (0, _utils.validateType)("Identifier")
}

}); const signatureDeclarationCommon = {

typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterDeclaration"),
parameters: (0, _utils.validateArrayOfType)(["Identifier", "RestElement"]),
typeAnnotation: (0, _utils.validateOptionalType)("TSTypeAnnotation")

}; const callConstructSignatureDeclaration = {

aliases: ["TSTypeElement"],
visitor: ["typeParameters", "parameters", "typeAnnotation"],
fields: signatureDeclarationCommon

}; (0, _utils.default)(“TSCallSignatureDeclaration”, callConstructSignatureDeclaration); (0, _utils.default)(“TSConstructSignatureDeclaration”, callConstructSignatureDeclaration); const namedTypeElementCommon = {

key: (0, _utils.validateType)("Expression"),
computed: (0, _utils.validate)(bool),
optional: (0, _utils.validateOptional)(bool)

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

aliases: ["TSTypeElement"],
visitor: ["key", "typeAnnotation", "initializer"],
fields: Object.assign({}, namedTypeElementCommon, {
  readonly: (0, _utils.validateOptional)(bool),
  typeAnnotation: (0, _utils.validateOptionalType)("TSTypeAnnotation"),
  initializer: (0, _utils.validateOptionalType)("Expression")
})

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

aliases: ["TSTypeElement"],
visitor: ["key", "typeParameters", "parameters", "typeAnnotation"],
fields: Object.assign({}, signatureDeclarationCommon, {}, namedTypeElementCommon)

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

aliases: ["TSTypeElement"],
visitor: ["parameters", "typeAnnotation"],
fields: {
  readonly: (0, _utils.validateOptional)(bool),
  parameters: (0, _utils.validateArrayOfType)("Identifier"),
  typeAnnotation: (0, _utils.validateOptionalType)("TSTypeAnnotation")
}

}); const tsKeywordTypes = [“TSAnyKeyword”, “TSBooleanKeyword”, “TSBigIntKeyword”, “TSNeverKeyword”, “TSNullKeyword”, “TSNumberKeyword”, “TSObjectKeyword”, “TSStringKeyword”, “TSSymbolKeyword”, “TSUndefinedKeyword”, “TSUnknownKeyword”, “TSVoidKeyword”];

for (const type of tsKeywordTypes) {

(0, _utils.default)(type, {
  aliases: ["TSType"],
  visitor: [],
  fields: {}
});

}

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

aliases: ["TSType"],
visitor: [],
fields: {}

}); const fnOrCtr = {

aliases: ["TSType"],
visitor: ["typeParameters", "parameters", "typeAnnotation"],
fields: signatureDeclarationCommon

}; (0, _utils.default)(“TSFunctionType”, fnOrCtr); (0, _utils.default)(“TSConstructorType”, fnOrCtr); (0, _utils.default)(“TSTypeReference”, {

aliases: ["TSType"],
visitor: ["typeName", "typeParameters"],
fields: {
  typeName: (0, _utils.validateType)("TSEntityName"),
  typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterInstantiation")
}

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

aliases: ["TSType"],
visitor: ["parameterName", "typeAnnotation"],
fields: {
  parameterName: (0, _utils.validateType)(["Identifier", "TSThisType"]),
  typeAnnotation: (0, _utils.validateType)("TSTypeAnnotation")
}

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

aliases: ["TSType"],
visitor: ["exprName"],
fields: {
  exprName: (0, _utils.validateType)(["TSEntityName", "TSImportType"])
}

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

aliases: ["TSType"],
visitor: ["members"],
fields: {
  members: (0, _utils.validateArrayOfType)("TSTypeElement")
}

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

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

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

aliases: ["TSType"],
visitor: ["elementTypes"],
fields: {
  elementTypes: (0, _utils.validateArrayOfType)("TSType")
}

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

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

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

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

}); const unionOrIntersection = {

aliases: ["TSType"],
visitor: ["types"],
fields: {
  types: (0, _utils.validateArrayOfType)("TSType")
}

}; (0, _utils.default)(“TSUnionType”, unionOrIntersection); (0, _utils.default)(“TSIntersectionType”, unionOrIntersection); (0, _utils.default)(“TSConditionalType”, {

aliases: ["TSType"],
visitor: ["checkType", "extendsType", "trueType", "falseType"],
fields: {
  checkType: (0, _utils.validateType)("TSType"),
  extendsType: (0, _utils.validateType)("TSType"),
  trueType: (0, _utils.validateType)("TSType"),
  falseType: (0, _utils.validateType)("TSType")
}

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

aliases: ["TSType"],
visitor: ["typeParameter"],
fields: {
  typeParameter: (0, _utils.validateType)("TSTypeParameter")
}

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

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

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

aliases: ["TSType"],
visitor: ["typeAnnotation"],
fields: {
  operator: (0, _utils.validate)((0, _utils.assertValueType)("string")),
  typeAnnotation: (0, _utils.validateType)("TSType")
}

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

aliases: ["TSType"],
visitor: ["objectType", "indexType"],
fields: {
  objectType: (0, _utils.validateType)("TSType"),
  indexType: (0, _utils.validateType)("TSType")
}

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

aliases: ["TSType"],
visitor: ["typeParameter", "typeAnnotation"],
fields: {
  readonly: (0, _utils.validateOptional)(bool),
  typeParameter: (0, _utils.validateType)("TSTypeParameter"),
  optional: (0, _utils.validateOptional)(bool),
  typeAnnotation: (0, _utils.validateOptionalType)("TSType")
}

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

aliases: ["TSType"],
visitor: ["literal"],
fields: {
  literal: (0, _utils.validateType)(["NumericLiteral", "StringLiteral", "BooleanLiteral"])
}

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

aliases: ["TSType"],
visitor: ["expression", "typeParameters"],
fields: {
  expression: (0, _utils.validateType)("TSEntityName"),
  typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterInstantiation")
}

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

aliases: ["Statement", "Declaration"],
visitor: ["id", "typeParameters", "extends", "body"],
fields: {
  declare: (0, _utils.validateOptional)(bool),
  id: (0, _utils.validateType)("Identifier"),
  typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterDeclaration"),
  extends: (0, _utils.validateOptional)((0, _utils.arrayOfType)("TSExpressionWithTypeArguments")),
  body: (0, _utils.validateType)("TSInterfaceBody")
}

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

visitor: ["body"],
fields: {
  body: (0, _utils.validateArrayOfType)("TSTypeElement")
}

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

aliases: ["Statement", "Declaration"],
visitor: ["id", "typeParameters", "typeAnnotation"],
fields: {
  declare: (0, _utils.validateOptional)(bool),
  id: (0, _utils.validateType)("Identifier"),
  typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterDeclaration"),
  typeAnnotation: (0, _utils.validateType)("TSType")
}

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

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

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

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

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

aliases: ["Statement", "Declaration"],
visitor: ["id", "members"],
fields: {
  declare: (0, _utils.validateOptional)(bool),
  const: (0, _utils.validateOptional)(bool),
  id: (0, _utils.validateType)("Identifier"),
  members: (0, _utils.validateArrayOfType)("TSEnumMember"),
  initializer: (0, _utils.validateOptionalType)("Expression")
}

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

visitor: ["id", "initializer"],
fields: {
  id: (0, _utils.validateType)(["Identifier", "StringLiteral"]),
  initializer: (0, _utils.validateOptionalType)("Expression")
}

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

aliases: ["Statement", "Declaration"],
visitor: ["id", "body"],
fields: {
  declare: (0, _utils.validateOptional)(bool),
  global: (0, _utils.validateOptional)(bool),
  id: (0, _utils.validateType)(["Identifier", "StringLiteral"]),
  body: (0, _utils.validateType)(["TSModuleBlock", "TSModuleDeclaration"])
}

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

aliases: ["Scopable", "Block", "BlockParent"],
visitor: ["body"],
fields: {
  body: (0, _utils.validateArrayOfType)("Statement")
}

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

aliases: ["TSType"],
visitor: ["argument", "qualifier", "typeParameters"],
fields: {
  argument: (0, _utils.validateType)("StringLiteral"),
  qualifier: (0, _utils.validateOptionalType)("TSEntityName"),
  typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterInstantiation")
}

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

aliases: ["Statement"],
visitor: ["id", "moduleReference"],
fields: {
  isExport: (0, _utils.validate)(bool),
  id: (0, _utils.validateType)("Identifier"),
  moduleReference: (0, _utils.validateType)(["TSEntityName", "TSExternalModuleReference"])
}

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

visitor: ["expression"],
fields: {
  expression: (0, _utils.validateType)("StringLiteral")
}

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

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

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

aliases: ["Statement"],
visitor: ["expression"],
fields: {
  expression: (0, _utils.validateType)("Expression")
}

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

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

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

visitor: ["typeAnnotation"],
fields: {
  typeAnnotation: {
    validate: (0, _utils.assertNodeType)("TSType")
  }
}

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

visitor: ["params"],
fields: {
  params: {
    validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("TSType")))
  }
}

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

visitor: ["params"],
fields: {
  params: {
    validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("TSTypeParameter")))
  }
}

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

builder: ["constraint", "default", "name"],
visitor: ["constraint", "default"],
fields: {
  name: {
    validate: (0, _utils.assertValueType)("string")
  },
  constraint: {
    validate: (0, _utils.assertNodeType)("TSType"),
    optional: true
  },
  default: {
    validate: (0, _utils.assertNodeType)("TSType"),
    optional: true
  }
}

});