“use strict”;

Object.defineProperty(exports, “__esModule”, {

value: true

}); exports.assertArrayExpression = assertArrayExpression; exports.assertAssignmentExpression = assertAssignmentExpression; exports.assertBinaryExpression = assertBinaryExpression; exports.assertInterpreterDirective = assertInterpreterDirective; exports.assertDirective = assertDirective; exports.assertDirectiveLiteral = assertDirectiveLiteral; exports.assertBlockStatement = assertBlockStatement; exports.assertBreakStatement = assertBreakStatement; exports.assertCallExpression = assertCallExpression; exports.assertCatchClause = assertCatchClause; exports.assertConditionalExpression = assertConditionalExpression; exports.assertContinueStatement = assertContinueStatement; exports.assertDebuggerStatement = assertDebuggerStatement; exports.assertDoWhileStatement = assertDoWhileStatement; exports.assertEmptyStatement = assertEmptyStatement; exports.assertExpressionStatement = assertExpressionStatement; exports.assertFile = assertFile; exports.assertForInStatement = assertForInStatement; exports.assertForStatement = assertForStatement; exports.assertFunctionDeclaration = assertFunctionDeclaration; exports.assertFunctionExpression = assertFunctionExpression; exports.assertIdentifier = assertIdentifier; exports.assertIfStatement = assertIfStatement; exports.assertLabeledStatement = assertLabeledStatement; exports.assertStringLiteral = assertStringLiteral; exports.assertNumericLiteral = assertNumericLiteral; exports.assertNullLiteral = assertNullLiteral; exports.assertBooleanLiteral = assertBooleanLiteral; exports.assertRegExpLiteral = assertRegExpLiteral; exports.assertLogicalExpression = assertLogicalExpression; exports.assertMemberExpression = assertMemberExpression; exports.assertNewExpression = assertNewExpression; exports.assertProgram = assertProgram; exports.assertObjectExpression = assertObjectExpression; exports.assertObjectMethod = assertObjectMethod; exports.assertObjectProperty = assertObjectProperty; exports.assertRestElement = assertRestElement; exports.assertReturnStatement = assertReturnStatement; exports.assertSequenceExpression = assertSequenceExpression; exports.assertParenthesizedExpression = assertParenthesizedExpression; exports.assertSwitchCase = assertSwitchCase; exports.assertSwitchStatement = assertSwitchStatement; exports.assertThisExpression = assertThisExpression; exports.assertThrowStatement = assertThrowStatement; exports.assertTryStatement = assertTryStatement; exports.assertUnaryExpression = assertUnaryExpression; exports.assertUpdateExpression = assertUpdateExpression; exports.assertVariableDeclaration = assertVariableDeclaration; exports.assertVariableDeclarator = assertVariableDeclarator; exports.assertWhileStatement = assertWhileStatement; exports.assertWithStatement = assertWithStatement; exports.assertAssignmentPattern = assertAssignmentPattern; exports.assertArrayPattern = assertArrayPattern; exports.assertArrowFunctionExpression = assertArrowFunctionExpression; exports.assertClassBody = assertClassBody; exports.assertClassDeclaration = assertClassDeclaration; exports.assertClassExpression = assertClassExpression; exports.assertExportAllDeclaration = assertExportAllDeclaration; exports.assertExportDefaultDeclaration = assertExportDefaultDeclaration; exports.assertExportNamedDeclaration = assertExportNamedDeclaration; exports.assertExportSpecifier = assertExportSpecifier; exports.assertForOfStatement = assertForOfStatement; exports.assertImportDeclaration = assertImportDeclaration; exports.assertImportDefaultSpecifier = assertImportDefaultSpecifier; exports.assertImportNamespaceSpecifier = assertImportNamespaceSpecifier; exports.assertImportSpecifier = assertImportSpecifier; exports.assertMetaProperty = assertMetaProperty; exports.assertClassMethod = assertClassMethod; exports.assertObjectPattern = assertObjectPattern; exports.assertSpreadElement = assertSpreadElement; exports.assertSuper = assertSuper; exports.assertTaggedTemplateExpression = assertTaggedTemplateExpression; exports.assertTemplateElement = assertTemplateElement; exports.assertTemplateLiteral = assertTemplateLiteral; exports.assertYieldExpression = assertYieldExpression; exports.assertAnyTypeAnnotation = assertAnyTypeAnnotation; exports.assertArrayTypeAnnotation = assertArrayTypeAnnotation; exports.assertBooleanTypeAnnotation = assertBooleanTypeAnnotation; exports.assertBooleanLiteralTypeAnnotation = assertBooleanLiteralTypeAnnotation; exports.assertNullLiteralTypeAnnotation = assertNullLiteralTypeAnnotation; exports.assertClassImplements = assertClassImplements; exports.assertDeclareClass = assertDeclareClass; exports.assertDeclareFunction = assertDeclareFunction; exports.assertDeclareInterface = assertDeclareInterface; exports.assertDeclareModule = assertDeclareModule; exports.assertDeclareModuleExports = assertDeclareModuleExports; exports.assertDeclareTypeAlias = assertDeclareTypeAlias; exports.assertDeclareOpaqueType = assertDeclareOpaqueType; exports.assertDeclareVariable = assertDeclareVariable; exports.assertDeclareExportDeclaration = assertDeclareExportDeclaration; exports.assertDeclareExportAllDeclaration = assertDeclareExportAllDeclaration; exports.assertDeclaredPredicate = assertDeclaredPredicate; exports.assertExistsTypeAnnotation = assertExistsTypeAnnotation; exports.assertFunctionTypeAnnotation = assertFunctionTypeAnnotation; exports.assertFunctionTypeParam = assertFunctionTypeParam; exports.assertGenericTypeAnnotation = assertGenericTypeAnnotation; exports.assertInferredPredicate = assertInferredPredicate; exports.assertInterfaceExtends = assertInterfaceExtends; exports.assertInterfaceDeclaration = assertInterfaceDeclaration; exports.assertInterfaceTypeAnnotation = assertInterfaceTypeAnnotation; exports.assertIntersectionTypeAnnotation = assertIntersectionTypeAnnotation; exports.assertMixedTypeAnnotation = assertMixedTypeAnnotation; exports.assertEmptyTypeAnnotation = assertEmptyTypeAnnotation; exports.assertNullableTypeAnnotation = assertNullableTypeAnnotation; exports.assertNumberLiteralTypeAnnotation = assertNumberLiteralTypeAnnotation; exports.assertNumberTypeAnnotation = assertNumberTypeAnnotation; exports.assertObjectTypeAnnotation = assertObjectTypeAnnotation; exports.assertObjectTypeInternalSlot = assertObjectTypeInternalSlot; exports.assertObjectTypeCallProperty = assertObjectTypeCallProperty; exports.assertObjectTypeIndexer = assertObjectTypeIndexer; exports.assertObjectTypeProperty = assertObjectTypeProperty; exports.assertObjectTypeSpreadProperty = assertObjectTypeSpreadProperty; exports.assertOpaqueType = assertOpaqueType; exports.assertQualifiedTypeIdentifier = assertQualifiedTypeIdentifier; exports.assertStringLiteralTypeAnnotation = assertStringLiteralTypeAnnotation; exports.assertStringTypeAnnotation = assertStringTypeAnnotation; exports.assertThisTypeAnnotation = assertThisTypeAnnotation; exports.assertTupleTypeAnnotation = assertTupleTypeAnnotation; exports.assertTypeofTypeAnnotation = assertTypeofTypeAnnotation; exports.assertTypeAlias = assertTypeAlias; exports.assertTypeAnnotation = assertTypeAnnotation; exports.assertTypeCastExpression = assertTypeCastExpression; exports.assertTypeParameter = assertTypeParameter; exports.assertTypeParameterDeclaration = assertTypeParameterDeclaration; exports.assertTypeParameterInstantiation = assertTypeParameterInstantiation; exports.assertUnionTypeAnnotation = assertUnionTypeAnnotation; exports.assertVariance = assertVariance; exports.assertVoidTypeAnnotation = assertVoidTypeAnnotation; exports.assertJSXAttribute = assertJSXAttribute; exports.assertJSXClosingElement = assertJSXClosingElement; exports.assertJSXElement = assertJSXElement; exports.assertJSXEmptyExpression = assertJSXEmptyExpression; exports.assertJSXExpressionContainer = assertJSXExpressionContainer; exports.assertJSXSpreadChild = assertJSXSpreadChild; exports.assertJSXIdentifier = assertJSXIdentifier; exports.assertJSXMemberExpression = assertJSXMemberExpression; exports.assertJSXNamespacedName = assertJSXNamespacedName; exports.assertJSXOpeningElement = assertJSXOpeningElement; exports.assertJSXSpreadAttribute = assertJSXSpreadAttribute; exports.assertJSXText = assertJSXText; exports.assertJSXFragment = assertJSXFragment; exports.assertJSXOpeningFragment = assertJSXOpeningFragment; exports.assertJSXClosingFragment = assertJSXClosingFragment; exports.assertNoop = assertNoop; exports.assertPlaceholder = assertPlaceholder; exports.assertV8IntrinsicIdentifier = assertV8IntrinsicIdentifier; exports.assertArgumentPlaceholder = assertArgumentPlaceholder; exports.assertAwaitExpression = assertAwaitExpression; exports.assertBindExpression = assertBindExpression; exports.assertClassProperty = assertClassProperty; exports.assertOptionalMemberExpression = assertOptionalMemberExpression; exports.assertPipelineTopicExpression = assertPipelineTopicExpression; exports.assertPipelineBareFunction = assertPipelineBareFunction; exports.assertPipelinePrimaryTopicReference = assertPipelinePrimaryTopicReference; exports.assertOptionalCallExpression = assertOptionalCallExpression; exports.assertClassPrivateProperty = assertClassPrivateProperty; exports.assertClassPrivateMethod = assertClassPrivateMethod; exports.assertImport = assertImport; exports.assertDecorator = assertDecorator; exports.assertDoExpression = assertDoExpression; exports.assertExportDefaultSpecifier = assertExportDefaultSpecifier; exports.assertExportNamespaceSpecifier = assertExportNamespaceSpecifier; exports.assertPrivateName = assertPrivateName; exports.assertBigIntLiteral = assertBigIntLiteral; exports.assertTSParameterProperty = assertTSParameterProperty; exports.assertTSDeclareFunction = assertTSDeclareFunction; exports.assertTSDeclareMethod = assertTSDeclareMethod; exports.assertTSQualifiedName = assertTSQualifiedName; exports.assertTSCallSignatureDeclaration = assertTSCallSignatureDeclaration; exports.assertTSConstructSignatureDeclaration = assertTSConstructSignatureDeclaration; exports.assertTSPropertySignature = assertTSPropertySignature; exports.assertTSMethodSignature = assertTSMethodSignature; exports.assertTSIndexSignature = assertTSIndexSignature; exports.assertTSAnyKeyword = assertTSAnyKeyword; exports.assertTSBooleanKeyword = assertTSBooleanKeyword; exports.assertTSBigIntKeyword = assertTSBigIntKeyword; exports.assertTSNeverKeyword = assertTSNeverKeyword; exports.assertTSNullKeyword = assertTSNullKeyword; exports.assertTSNumberKeyword = assertTSNumberKeyword; exports.assertTSObjectKeyword = assertTSObjectKeyword; exports.assertTSStringKeyword = assertTSStringKeyword; exports.assertTSSymbolKeyword = assertTSSymbolKeyword; exports.assertTSUndefinedKeyword = assertTSUndefinedKeyword; exports.assertTSUnknownKeyword = assertTSUnknownKeyword; exports.assertTSVoidKeyword = assertTSVoidKeyword; exports.assertTSThisType = assertTSThisType; exports.assertTSFunctionType = assertTSFunctionType; exports.assertTSConstructorType = assertTSConstructorType; exports.assertTSTypeReference = assertTSTypeReference; exports.assertTSTypePredicate = assertTSTypePredicate; exports.assertTSTypeQuery = assertTSTypeQuery; exports.assertTSTypeLiteral = assertTSTypeLiteral; exports.assertTSArrayType = assertTSArrayType; exports.assertTSTupleType = assertTSTupleType; exports.assertTSOptionalType = assertTSOptionalType; exports.assertTSRestType = assertTSRestType; exports.assertTSUnionType = assertTSUnionType; exports.assertTSIntersectionType = assertTSIntersectionType; exports.assertTSConditionalType = assertTSConditionalType; exports.assertTSInferType = assertTSInferType; exports.assertTSParenthesizedType = assertTSParenthesizedType; exports.assertTSTypeOperator = assertTSTypeOperator; exports.assertTSIndexedAccessType = assertTSIndexedAccessType; exports.assertTSMappedType = assertTSMappedType; exports.assertTSLiteralType = assertTSLiteralType; exports.assertTSExpressionWithTypeArguments = assertTSExpressionWithTypeArguments; exports.assertTSInterfaceDeclaration = assertTSInterfaceDeclaration; exports.assertTSInterfaceBody = assertTSInterfaceBody; exports.assertTSTypeAliasDeclaration = assertTSTypeAliasDeclaration; exports.assertTSAsExpression = assertTSAsExpression; exports.assertTSTypeAssertion = assertTSTypeAssertion; exports.assertTSEnumDeclaration = assertTSEnumDeclaration; exports.assertTSEnumMember = assertTSEnumMember; exports.assertTSModuleDeclaration = assertTSModuleDeclaration; exports.assertTSModuleBlock = assertTSModuleBlock; exports.assertTSImportType = assertTSImportType; exports.assertTSImportEqualsDeclaration = assertTSImportEqualsDeclaration; exports.assertTSExternalModuleReference = assertTSExternalModuleReference; exports.assertTSNonNullExpression = assertTSNonNullExpression; exports.assertTSExportAssignment = assertTSExportAssignment; exports.assertTSNamespaceExportDeclaration = assertTSNamespaceExportDeclaration; exports.assertTSTypeAnnotation = assertTSTypeAnnotation; exports.assertTSTypeParameterInstantiation = assertTSTypeParameterInstantiation; exports.assertTSTypeParameterDeclaration = assertTSTypeParameterDeclaration; exports.assertTSTypeParameter = assertTSTypeParameter; exports.assertExpression = assertExpression; exports.assertBinary = assertBinary; exports.assertScopable = assertScopable; exports.assertBlockParent = assertBlockParent; exports.assertBlock = assertBlock; exports.assertStatement = assertStatement; exports.assertTerminatorless = assertTerminatorless; exports.assertCompletionStatement = assertCompletionStatement; exports.assertConditional = assertConditional; exports.assertLoop = assertLoop; exports.assertWhile = assertWhile; exports.assertExpressionWrapper = assertExpressionWrapper; exports.assertFor = assertFor; exports.assertForXStatement = assertForXStatement; exports.assertFunction = assertFunction; exports.assertFunctionParent = assertFunctionParent; exports.assertPureish = assertPureish; exports.assertDeclaration = assertDeclaration; exports.assertPatternLike = assertPatternLike; exports.assertLVal = assertLVal; exports.assertTSEntityName = assertTSEntityName; exports.assertLiteral = assertLiteral; exports.assertImmutable = assertImmutable; exports.assertUserWhitespacable = assertUserWhitespacable; exports.assertMethod = assertMethod; exports.assertObjectMember = assertObjectMember; exports.assertProperty = assertProperty; exports.assertUnaryLike = assertUnaryLike; exports.assertPattern = assertPattern; exports.assertClass = assertClass; exports.assertModuleDeclaration = assertModuleDeclaration; exports.assertExportDeclaration = assertExportDeclaration; exports.assertModuleSpecifier = assertModuleSpecifier; exports.assertFlow = assertFlow; exports.assertFlowType = assertFlowType; exports.assertFlowBaseAnnotation = assertFlowBaseAnnotation; exports.assertFlowDeclaration = assertFlowDeclaration; exports.assertFlowPredicate = assertFlowPredicate; exports.assertJSX = assertJSX; exports.assertPrivate = assertPrivate; exports.assertTSTypeElement = assertTSTypeElement; exports.assertTSType = assertTSType; exports.assertNumberLiteral = assertNumberLiteral; exports.assertRegexLiteral = assertRegexLiteral; exports.assertRestProperty = assertRestProperty; exports.assertSpreadProperty = assertSpreadProperty;

var _is = _interopRequireDefault(require(“../../validators/is”));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function assert(type, node, opts) {

if (!(0, _is.default)(type, node, opts)) {
  throw new Error(`Expected type "${type}" with option ${JSON.stringify(opts)}, ` + `but instead got "${node.type}".`);
}

}

function assertArrayExpression(node, opts = {}) {

assert("ArrayExpression", node, opts);

}

function assertAssignmentExpression(node, opts = {}) {

assert("AssignmentExpression", node, opts);

}

function assertBinaryExpression(node, opts = {}) {

assert("BinaryExpression", node, opts);

}

function assertInterpreterDirective(node, opts = {}) {

assert("InterpreterDirective", node, opts);

}

function assertDirective(node, opts = {}) {

assert("Directive", node, opts);

}

function assertDirectiveLiteral(node, opts = {}) {

assert("DirectiveLiteral", node, opts);

}

function assertBlockStatement(node, opts = {}) {

assert("BlockStatement", node, opts);

}

function assertBreakStatement(node, opts = {}) {

assert("BreakStatement", node, opts);

}

function assertCallExpression(node, opts = {}) {

assert("CallExpression", node, opts);

}

function assertCatchClause(node, opts = {}) {

assert("CatchClause", node, opts);

}

function assertConditionalExpression(node, opts = {}) {

assert("ConditionalExpression", node, opts);

}

function assertContinueStatement(node, opts = {}) {

assert("ContinueStatement", node, opts);

}

function assertDebuggerStatement(node, opts = {}) {

assert("DebuggerStatement", node, opts);

}

function assertDoWhileStatement(node, opts = {}) {

assert("DoWhileStatement", node, opts);

}

function assertEmptyStatement(node, opts = {}) {

assert("EmptyStatement", node, opts);

}

function assertExpressionStatement(node, opts = {}) {

assert("ExpressionStatement", node, opts);

}

function assertFile(node, opts = {}) {

assert("File", node, opts);

}

function assertForInStatement(node, opts = {}) {

assert("ForInStatement", node, opts);

}

function assertForStatement(node, opts = {}) {

assert("ForStatement", node, opts);

}

function assertFunctionDeclaration(node, opts = {}) {

assert("FunctionDeclaration", node, opts);

}

function assertFunctionExpression(node, opts = {}) {

assert("FunctionExpression", node, opts);

}

function assertIdentifier(node, opts = {}) {

assert("Identifier", node, opts);

}

function assertIfStatement(node, opts = {}) {

assert("IfStatement", node, opts);

}

function assertLabeledStatement(node, opts = {}) {

assert("LabeledStatement", node, opts);

}

function assertStringLiteral(node, opts = {}) {

assert("StringLiteral", node, opts);

}

function assertNumericLiteral(node, opts = {}) {

assert("NumericLiteral", node, opts);

}

function assertNullLiteral(node, opts = {}) {

assert("NullLiteral", node, opts);

}

function assertBooleanLiteral(node, opts = {}) {

assert("BooleanLiteral", node, opts);

}

function assertRegExpLiteral(node, opts = {}) {

assert("RegExpLiteral", node, opts);

}

function assertLogicalExpression(node, opts = {}) {

assert("LogicalExpression", node, opts);

}

function assertMemberExpression(node, opts = {}) {

assert("MemberExpression", node, opts);

}

function assertNewExpression(node, opts = {}) {

assert("NewExpression", node, opts);

}

function assertProgram(node, opts = {}) {

assert("Program", node, opts);

}

function assertObjectExpression(node, opts = {}) {

assert("ObjectExpression", node, opts);

}

function assertObjectMethod(node, opts = {}) {

assert("ObjectMethod", node, opts);

}

function assertObjectProperty(node, opts = {}) {

assert("ObjectProperty", node, opts);

}

function assertRestElement(node, opts = {}) {

assert("RestElement", node, opts);

}

function assertReturnStatement(node, opts = {}) {

assert("ReturnStatement", node, opts);

}

function assertSequenceExpression(node, opts = {}) {

assert("SequenceExpression", node, opts);

}

function assertParenthesizedExpression(node, opts = {}) {

assert("ParenthesizedExpression", node, opts);

}

function assertSwitchCase(node, opts = {}) {

assert("SwitchCase", node, opts);

}

function assertSwitchStatement(node, opts = {}) {

assert("SwitchStatement", node, opts);

}

function assertThisExpression(node, opts = {}) {

assert("ThisExpression", node, opts);

}

function assertThrowStatement(node, opts = {}) {

assert("ThrowStatement", node, opts);

}

function assertTryStatement(node, opts = {}) {

assert("TryStatement", node, opts);

}

function assertUnaryExpression(node, opts = {}) {

assert("UnaryExpression", node, opts);

}

function assertUpdateExpression(node, opts = {}) {

assert("UpdateExpression", node, opts);

}

function assertVariableDeclaration(node, opts = {}) {

assert("VariableDeclaration", node, opts);

}

function assertVariableDeclarator(node, opts = {}) {

assert("VariableDeclarator", node, opts);

}

function assertWhileStatement(node, opts = {}) {

assert("WhileStatement", node, opts);

}

function assertWithStatement(node, opts = {}) {

assert("WithStatement", node, opts);

}

function assertAssignmentPattern(node, opts = {}) {

assert("AssignmentPattern", node, opts);

}

function assertArrayPattern(node, opts = {}) {

assert("ArrayPattern", node, opts);

}

function assertArrowFunctionExpression(node, opts = {}) {

assert("ArrowFunctionExpression", node, opts);

}

function assertClassBody(node, opts = {}) {

assert("ClassBody", node, opts);

}

function assertClassDeclaration(node, opts = {}) {

assert("ClassDeclaration", node, opts);

}

function assertClassExpression(node, opts = {}) {

assert("ClassExpression", node, opts);

}

function assertExportAllDeclaration(node, opts = {}) {

assert("ExportAllDeclaration", node, opts);

}

function assertExportDefaultDeclaration(node, opts = {}) {

assert("ExportDefaultDeclaration", node, opts);

}

function assertExportNamedDeclaration(node, opts = {}) {

assert("ExportNamedDeclaration", node, opts);

}

function assertExportSpecifier(node, opts = {}) {

assert("ExportSpecifier", node, opts);

}

function assertForOfStatement(node, opts = {}) {

assert("ForOfStatement", node, opts);

}

function assertImportDeclaration(node, opts = {}) {

assert("ImportDeclaration", node, opts);

}

function assertImportDefaultSpecifier(node, opts = {}) {

assert("ImportDefaultSpecifier", node, opts);

}

function assertImportNamespaceSpecifier(node, opts = {}) {

assert("ImportNamespaceSpecifier", node, opts);

}

function assertImportSpecifier(node, opts = {}) {

assert("ImportSpecifier", node, opts);

}

function assertMetaProperty(node, opts = {}) {

assert("MetaProperty", node, opts);

}

function assertClassMethod(node, opts = {}) {

assert("ClassMethod", node, opts);

}

function assertObjectPattern(node, opts = {}) {

assert("ObjectPattern", node, opts);

}

function assertSpreadElement(node, opts = {}) {

assert("SpreadElement", node, opts);

}

function assertSuper(node, opts = {}) {

assert("Super", node, opts);

}

function assertTaggedTemplateExpression(node, opts = {}) {

assert("TaggedTemplateExpression", node, opts);

}

function assertTemplateElement(node, opts = {}) {

assert("TemplateElement", node, opts);

}

function assertTemplateLiteral(node, opts = {}) {

assert("TemplateLiteral", node, opts);

}

function assertYieldExpression(node, opts = {}) {

assert("YieldExpression", node, opts);

}

function assertAnyTypeAnnotation(node, opts = {}) {

assert("AnyTypeAnnotation", node, opts);

}

function assertArrayTypeAnnotation(node, opts = {}) {

assert("ArrayTypeAnnotation", node, opts);

}

function assertBooleanTypeAnnotation(node, opts = {}) {

assert("BooleanTypeAnnotation", node, opts);

}

function assertBooleanLiteralTypeAnnotation(node, opts = {}) {

assert("BooleanLiteralTypeAnnotation", node, opts);

}

function assertNullLiteralTypeAnnotation(node, opts = {}) {

assert("NullLiteralTypeAnnotation", node, opts);

}

function assertClassImplements(node, opts = {}) {

assert("ClassImplements", node, opts);

}

function assertDeclareClass(node, opts = {}) {

assert("DeclareClass", node, opts);

}

function assertDeclareFunction(node, opts = {}) {

assert("DeclareFunction", node, opts);

}

function assertDeclareInterface(node, opts = {}) {

assert("DeclareInterface", node, opts);

}

function assertDeclareModule(node, opts = {}) {

assert("DeclareModule", node, opts);

}

function assertDeclareModuleExports(node, opts = {}) {

assert("DeclareModuleExports", node, opts);

}

function assertDeclareTypeAlias(node, opts = {}) {

assert("DeclareTypeAlias", node, opts);

}

function assertDeclareOpaqueType(node, opts = {}) {

assert("DeclareOpaqueType", node, opts);

}

function assertDeclareVariable(node, opts = {}) {

assert("DeclareVariable", node, opts);

}

function assertDeclareExportDeclaration(node, opts = {}) {

assert("DeclareExportDeclaration", node, opts);

}

function assertDeclareExportAllDeclaration(node, opts = {}) {

assert("DeclareExportAllDeclaration", node, opts);

}

function assertDeclaredPredicate(node, opts = {}) {

assert("DeclaredPredicate", node, opts);

}

function assertExistsTypeAnnotation(node, opts = {}) {

assert("ExistsTypeAnnotation", node, opts);

}

function assertFunctionTypeAnnotation(node, opts = {}) {

assert("FunctionTypeAnnotation", node, opts);

}

function assertFunctionTypeParam(node, opts = {}) {

assert("FunctionTypeParam", node, opts);

}

function assertGenericTypeAnnotation(node, opts = {}) {

assert("GenericTypeAnnotation", node, opts);

}

function assertInferredPredicate(node, opts = {}) {

assert("InferredPredicate", node, opts);

}

function assertInterfaceExtends(node, opts = {}) {

assert("InterfaceExtends", node, opts);

}

function assertInterfaceDeclaration(node, opts = {}) {

assert("InterfaceDeclaration", node, opts);

}

function assertInterfaceTypeAnnotation(node, opts = {}) {

assert("InterfaceTypeAnnotation", node, opts);

}

function assertIntersectionTypeAnnotation(node, opts = {}) {

assert("IntersectionTypeAnnotation", node, opts);

}

function assertMixedTypeAnnotation(node, opts = {}) {

assert("MixedTypeAnnotation", node, opts);

}

function assertEmptyTypeAnnotation(node, opts = {}) {

assert("EmptyTypeAnnotation", node, opts);

}

function assertNullableTypeAnnotation(node, opts = {}) {

assert("NullableTypeAnnotation", node, opts);

}

function assertNumberLiteralTypeAnnotation(node, opts = {}) {

assert("NumberLiteralTypeAnnotation", node, opts);

}

function assertNumberTypeAnnotation(node, opts = {}) {

assert("NumberTypeAnnotation", node, opts);

}

function assertObjectTypeAnnotation(node, opts = {}) {

assert("ObjectTypeAnnotation", node, opts);

}

function assertObjectTypeInternalSlot(node, opts = {}) {

assert("ObjectTypeInternalSlot", node, opts);

}

function assertObjectTypeCallProperty(node, opts = {}) {

assert("ObjectTypeCallProperty", node, opts);

}

function assertObjectTypeIndexer(node, opts = {}) {

assert("ObjectTypeIndexer", node, opts);

}

function assertObjectTypeProperty(node, opts = {}) {

assert("ObjectTypeProperty", node, opts);

}

function assertObjectTypeSpreadProperty(node, opts = {}) {

assert("ObjectTypeSpreadProperty", node, opts);

}

function assertOpaqueType(node, opts = {}) {

assert("OpaqueType", node, opts);

}

function assertQualifiedTypeIdentifier(node, opts = {}) {

assert("QualifiedTypeIdentifier", node, opts);

}

function assertStringLiteralTypeAnnotation(node, opts = {}) {

assert("StringLiteralTypeAnnotation", node, opts);

}

function assertStringTypeAnnotation(node, opts = {}) {

assert("StringTypeAnnotation", node, opts);

}

function assertThisTypeAnnotation(node, opts = {}) {

assert("ThisTypeAnnotation", node, opts);

}

function assertTupleTypeAnnotation(node, opts = {}) {

assert("TupleTypeAnnotation", node, opts);

}

function assertTypeofTypeAnnotation(node, opts = {}) {

assert("TypeofTypeAnnotation", node, opts);

}

function assertTypeAlias(node, opts = {}) {

assert("TypeAlias", node, opts);

}

function assertTypeAnnotation(node, opts = {}) {

assert("TypeAnnotation", node, opts);

}

function assertTypeCastExpression(node, opts = {}) {

assert("TypeCastExpression", node, opts);

}

function assertTypeParameter(node, opts = {}) {

assert("TypeParameter", node, opts);

}

function assertTypeParameterDeclaration(node, opts = {}) {

assert("TypeParameterDeclaration", node, opts);

}

function assertTypeParameterInstantiation(node, opts = {}) {

assert("TypeParameterInstantiation", node, opts);

}

function assertUnionTypeAnnotation(node, opts = {}) {

assert("UnionTypeAnnotation", node, opts);

}

function assertVariance(node, opts = {}) {

assert("Variance", node, opts);

}

function assertVoidTypeAnnotation(node, opts = {}) {

assert("VoidTypeAnnotation", node, opts);

}

function assertJSXAttribute(node, opts = {}) {

assert("JSXAttribute", node, opts);

}

function assertJSXClosingElement(node, opts = {}) {

assert("JSXClosingElement", node, opts);

}

function assertJSXElement(node, opts = {}) {

assert("JSXElement", node, opts);

}

function assertJSXEmptyExpression(node, opts = {}) {

assert("JSXEmptyExpression", node, opts);

}

function assertJSXExpressionContainer(node, opts = {}) {

assert("JSXExpressionContainer", node, opts);

}

function assertJSXSpreadChild(node, opts = {}) {

assert("JSXSpreadChild", node, opts);

}

function assertJSXIdentifier(node, opts = {}) {

assert("JSXIdentifier", node, opts);

}

function assertJSXMemberExpression(node, opts = {}) {

assert("JSXMemberExpression", node, opts);

}

function assertJSXNamespacedName(node, opts = {}) {

assert("JSXNamespacedName", node, opts);

}

function assertJSXOpeningElement(node, opts = {}) {

assert("JSXOpeningElement", node, opts);

}

function assertJSXSpreadAttribute(node, opts = {}) {

assert("JSXSpreadAttribute", node, opts);

}

function assertJSXText(node, opts = {}) {

assert("JSXText", node, opts);

}

function assertJSXFragment(node, opts = {}) {

assert("JSXFragment", node, opts);

}

function assertJSXOpeningFragment(node, opts = {}) {

assert("JSXOpeningFragment", node, opts);

}

function assertJSXClosingFragment(node, opts = {}) {

assert("JSXClosingFragment", node, opts);

}

function assertNoop(node, opts = {}) {

assert("Noop", node, opts);

}

function assertPlaceholder(node, opts = {}) {

assert("Placeholder", node, opts);

}

function assertV8IntrinsicIdentifier(node, opts = {}) {

assert("V8IntrinsicIdentifier", node, opts);

}

function assertArgumentPlaceholder(node, opts = {}) {

assert("ArgumentPlaceholder", node, opts);

}

function assertAwaitExpression(node, opts = {}) {

assert("AwaitExpression", node, opts);

}

function assertBindExpression(node, opts = {}) {

assert("BindExpression", node, opts);

}

function assertClassProperty(node, opts = {}) {

assert("ClassProperty", node, opts);

}

function assertOptionalMemberExpression(node, opts = {}) {

assert("OptionalMemberExpression", node, opts);

}

function assertPipelineTopicExpression(node, opts = {}) {

assert("PipelineTopicExpression", node, opts);

}

function assertPipelineBareFunction(node, opts = {}) {

assert("PipelineBareFunction", node, opts);

}

function assertPipelinePrimaryTopicReference(node, opts = {}) {

assert("PipelinePrimaryTopicReference", node, opts);

}

function assertOptionalCallExpression(node, opts = {}) {

assert("OptionalCallExpression", node, opts);

}

function assertClassPrivateProperty(node, opts = {}) {

assert("ClassPrivateProperty", node, opts);

}

function assertClassPrivateMethod(node, opts = {}) {

assert("ClassPrivateMethod", node, opts);

}

function assertImport(node, opts = {}) {

assert("Import", node, opts);

}

function assertDecorator(node, opts = {}) {

assert("Decorator", node, opts);

}

function assertDoExpression(node, opts = {}) {

assert("DoExpression", node, opts);

}

function assertExportDefaultSpecifier(node, opts = {}) {

assert("ExportDefaultSpecifier", node, opts);

}

function assertExportNamespaceSpecifier(node, opts = {}) {

assert("ExportNamespaceSpecifier", node, opts);

}

function assertPrivateName(node, opts = {}) {

assert("PrivateName", node, opts);

}

function assertBigIntLiteral(node, opts = {}) {

assert("BigIntLiteral", node, opts);

}

function assertTSParameterProperty(node, opts = {}) {

assert("TSParameterProperty", node, opts);

}

function assertTSDeclareFunction(node, opts = {}) {

assert("TSDeclareFunction", node, opts);

}

function assertTSDeclareMethod(node, opts = {}) {

assert("TSDeclareMethod", node, opts);

}

function assertTSQualifiedName(node, opts = {}) {

assert("TSQualifiedName", node, opts);

}

function assertTSCallSignatureDeclaration(node, opts = {}) {

assert("TSCallSignatureDeclaration", node, opts);

}

function assertTSConstructSignatureDeclaration(node, opts = {}) {

assert("TSConstructSignatureDeclaration", node, opts);

}

function assertTSPropertySignature(node, opts = {}) {

assert("TSPropertySignature", node, opts);

}

function assertTSMethodSignature(node, opts = {}) {

assert("TSMethodSignature", node, opts);

}

function assertTSIndexSignature(node, opts = {}) {

assert("TSIndexSignature", node, opts);

}

function assertTSAnyKeyword(node, opts = {}) {

assert("TSAnyKeyword", node, opts);

}

function assertTSBooleanKeyword(node, opts = {}) {

assert("TSBooleanKeyword", node, opts);

}

function assertTSBigIntKeyword(node, opts = {}) {

assert("TSBigIntKeyword", node, opts);

}

function assertTSNeverKeyword(node, opts = {}) {

assert("TSNeverKeyword", node, opts);

}

function assertTSNullKeyword(node, opts = {}) {

assert("TSNullKeyword", node, opts);

}

function assertTSNumberKeyword(node, opts = {}) {

assert("TSNumberKeyword", node, opts);

}

function assertTSObjectKeyword(node, opts = {}) {

assert("TSObjectKeyword", node, opts);

}

function assertTSStringKeyword(node, opts = {}) {

assert("TSStringKeyword", node, opts);

}

function assertTSSymbolKeyword(node, opts = {}) {

assert("TSSymbolKeyword", node, opts);

}

function assertTSUndefinedKeyword(node, opts = {}) {

assert("TSUndefinedKeyword", node, opts);

}

function assertTSUnknownKeyword(node, opts = {}) {

assert("TSUnknownKeyword", node, opts);

}

function assertTSVoidKeyword(node, opts = {}) {

assert("TSVoidKeyword", node, opts);

}

function assertTSThisType(node, opts = {}) {

assert("TSThisType", node, opts);

}

function assertTSFunctionType(node, opts = {}) {

assert("TSFunctionType", node, opts);

}

function assertTSConstructorType(node, opts = {}) {

assert("TSConstructorType", node, opts);

}

function assertTSTypeReference(node, opts = {}) {

assert("TSTypeReference", node, opts);

}

function assertTSTypePredicate(node, opts = {}) {

assert("TSTypePredicate", node, opts);

}

function assertTSTypeQuery(node, opts = {}) {

assert("TSTypeQuery", node, opts);

}

function assertTSTypeLiteral(node, opts = {}) {

assert("TSTypeLiteral", node, opts);

}

function assertTSArrayType(node, opts = {}) {

assert("TSArrayType", node, opts);

}

function assertTSTupleType(node, opts = {}) {

assert("TSTupleType", node, opts);

}

function assertTSOptionalType(node, opts = {}) {

assert("TSOptionalType", node, opts);

}

function assertTSRestType(node, opts = {}) {

assert("TSRestType", node, opts);

}

function assertTSUnionType(node, opts = {}) {

assert("TSUnionType", node, opts);

}

function assertTSIntersectionType(node, opts = {}) {

assert("TSIntersectionType", node, opts);

}

function assertTSConditionalType(node, opts = {}) {

assert("TSConditionalType", node, opts);

}

function assertTSInferType(node, opts = {}) {

assert("TSInferType", node, opts);

}

function assertTSParenthesizedType(node, opts = {}) {

assert("TSParenthesizedType", node, opts);

}

function assertTSTypeOperator(node, opts = {}) {

assert("TSTypeOperator", node, opts);

}

function assertTSIndexedAccessType(node, opts = {}) {

assert("TSIndexedAccessType", node, opts);

}

function assertTSMappedType(node, opts = {}) {

assert("TSMappedType", node, opts);

}

function assertTSLiteralType(node, opts = {}) {

assert("TSLiteralType", node, opts);

}

function assertTSExpressionWithTypeArguments(node, opts = {}) {

assert("TSExpressionWithTypeArguments", node, opts);

}

function assertTSInterfaceDeclaration(node, opts = {}) {

assert("TSInterfaceDeclaration", node, opts);

}

function assertTSInterfaceBody(node, opts = {}) {

assert("TSInterfaceBody", node, opts);

}

function assertTSTypeAliasDeclaration(node, opts = {}) {

assert("TSTypeAliasDeclaration", node, opts);

}

function assertTSAsExpression(node, opts = {}) {

assert("TSAsExpression", node, opts);

}

function assertTSTypeAssertion(node, opts = {}) {

assert("TSTypeAssertion", node, opts);

}

function assertTSEnumDeclaration(node, opts = {}) {

assert("TSEnumDeclaration", node, opts);

}

function assertTSEnumMember(node, opts = {}) {

assert("TSEnumMember", node, opts);

}

function assertTSModuleDeclaration(node, opts = {}) {

assert("TSModuleDeclaration", node, opts);

}

function assertTSModuleBlock(node, opts = {}) {

assert("TSModuleBlock", node, opts);

}

function assertTSImportType(node, opts = {}) {

assert("TSImportType", node, opts);

}

function assertTSImportEqualsDeclaration(node, opts = {}) {

assert("TSImportEqualsDeclaration", node, opts);

}

function assertTSExternalModuleReference(node, opts = {}) {

assert("TSExternalModuleReference", node, opts);

}

function assertTSNonNullExpression(node, opts = {}) {

assert("TSNonNullExpression", node, opts);

}

function assertTSExportAssignment(node, opts = {}) {

assert("TSExportAssignment", node, opts);

}

function assertTSNamespaceExportDeclaration(node, opts = {}) {

assert("TSNamespaceExportDeclaration", node, opts);

}

function assertTSTypeAnnotation(node, opts = {}) {

assert("TSTypeAnnotation", node, opts);

}

function assertTSTypeParameterInstantiation(node, opts = {}) {

assert("TSTypeParameterInstantiation", node, opts);

}

function assertTSTypeParameterDeclaration(node, opts = {}) {

assert("TSTypeParameterDeclaration", node, opts);

}

function assertTSTypeParameter(node, opts = {}) {

assert("TSTypeParameter", node, opts);

}

function assertExpression(node, opts = {}) {

assert("Expression", node, opts);

}

function assertBinary(node, opts = {}) {

assert("Binary", node, opts);

}

function assertScopable(node, opts = {}) {

assert("Scopable", node, opts);

}

function assertBlockParent(node, opts = {}) {

assert("BlockParent", node, opts);

}

function assertBlock(node, opts = {}) {

assert("Block", node, opts);

}

function assertStatement(node, opts = {}) {

assert("Statement", node, opts);

}

function assertTerminatorless(node, opts = {}) {

assert("Terminatorless", node, opts);

}

function assertCompletionStatement(node, opts = {}) {

assert("CompletionStatement", node, opts);

}

function assertConditional(node, opts = {}) {

assert("Conditional", node, opts);

}

function assertLoop(node, opts = {}) {

assert("Loop", node, opts);

}

function assertWhile(node, opts = {}) {

assert("While", node, opts);

}

function assertExpressionWrapper(node, opts = {}) {

assert("ExpressionWrapper", node, opts);

}

function assertFor(node, opts = {}) {

assert("For", node, opts);

}

function assertForXStatement(node, opts = {}) {

assert("ForXStatement", node, opts);

}

function assertFunction(node, opts = {}) {

assert("Function", node, opts);

}

function assertFunctionParent(node, opts = {}) {

assert("FunctionParent", node, opts);

}

function assertPureish(node, opts = {}) {

assert("Pureish", node, opts);

}

function assertDeclaration(node, opts = {}) {

assert("Declaration", node, opts);

}

function assertPatternLike(node, opts = {}) {

assert("PatternLike", node, opts);

}

function assertLVal(node, opts = {}) {

assert("LVal", node, opts);

}

function assertTSEntityName(node, opts = {}) {

assert("TSEntityName", node, opts);

}

function assertLiteral(node, opts = {}) {

assert("Literal", node, opts);

}

function assertImmutable(node, opts = {}) {

assert("Immutable", node, opts);

}

function assertUserWhitespacable(node, opts = {}) {

assert("UserWhitespacable", node, opts);

}

function assertMethod(node, opts = {}) {

assert("Method", node, opts);

}

function assertObjectMember(node, opts = {}) {

assert("ObjectMember", node, opts);

}

function assertProperty(node, opts = {}) {

assert("Property", node, opts);

}

function assertUnaryLike(node, opts = {}) {

assert("UnaryLike", node, opts);

}

function assertPattern(node, opts = {}) {

assert("Pattern", node, opts);

}

function assertClass(node, opts = {}) {

assert("Class", node, opts);

}

function assertModuleDeclaration(node, opts = {}) {

assert("ModuleDeclaration", node, opts);

}

function assertExportDeclaration(node, opts = {}) {

assert("ExportDeclaration", node, opts);

}

function assertModuleSpecifier(node, opts = {}) {

assert("ModuleSpecifier", node, opts);

}

function assertFlow(node, opts = {}) {

assert("Flow", node, opts);

}

function assertFlowType(node, opts = {}) {

assert("FlowType", node, opts);

}

function assertFlowBaseAnnotation(node, opts = {}) {

assert("FlowBaseAnnotation", node, opts);

}

function assertFlowDeclaration(node, opts = {}) {

assert("FlowDeclaration", node, opts);

}

function assertFlowPredicate(node, opts = {}) {

assert("FlowPredicate", node, opts);

}

function assertJSX(node, opts = {}) {

assert("JSX", node, opts);

}

function assertPrivate(node, opts = {}) {

assert("Private", node, opts);

}

function assertTSTypeElement(node, opts = {}) {

assert("TSTypeElement", node, opts);

}

function assertTSType(node, opts = {}) {

assert("TSType", node, opts);

}

function assertNumberLiteral(node, opts) {

console.trace("The node type NumberLiteral has been renamed to NumericLiteral");
assert("NumberLiteral", node, opts);

}

function assertRegexLiteral(node, opts) {

console.trace("The node type RegexLiteral has been renamed to RegExpLiteral");
assert("RegexLiteral", node, opts);

}

function assertRestProperty(node, opts) {

console.trace("The node type RestProperty has been renamed to RestElement");
assert("RestProperty", node, opts);

}

function assertSpreadProperty(node, opts) {

console.trace("The node type SpreadProperty has been renamed to SpreadElement");
assert("SpreadProperty", node, opts);

}