@signpostmarv/ts-assert 0.1.2 → 0.2.0

package/generated/assertions.js

@@ -1,777 +1,777 @@
 import ts from "typescript";
 import assert from "node:assert/strict";
-export function isAccessor(node, message = "node is not a AccessorDeclaration") {
+export function isAccessor(node, message = `expected AccessorDeclaration, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isAccessor(node), true, message);
 }
-export function isArrayBindingElement(node, message = "node is not a ArrayBindingElement") {
+export function isArrayBindingElement(node, message = `expected ArrayBindingElement, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isArrayBindingElement(node), true, message);
 }
-export function isArrayBindingPattern(node, message = "node is not a ArrayBindingPattern") {
+export function isArrayBindingPattern(node, message = `expected ArrayBindingPattern, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isArrayBindingPattern(node), true, message);
 }
-export function isArrayLiteralExpression(node, message = "node is not a ArrayLiteralExpression") {
+export function isArrayLiteralExpression(node, message = `expected ArrayLiteralExpression, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isArrayLiteralExpression(node), true, message);
 }
-export function isArrayTypeNode(node, message = "node is not a ArrayTypeNode") {
+export function isArrayTypeNode(node, message = `expected ArrayTypeNode, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isArrayTypeNode(node), true, message);
 }
-export function isArrowFunction(node, message = "node is not a ArrowFunction") {
+export function isArrowFunction(node, message = `expected ArrowFunction, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isArrowFunction(node), true, message);
 }
-export function isAsExpression(node, message = "node is not a AsExpression") {
+export function isAsExpression(node, message = `expected AsExpression, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isAsExpression(node), true, message);
 }
-export function isAssertionExpression(node, message = "node is not a AssertionExpression") {
+export function isAssertionExpression(node, message = `expected AssertionExpression, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isAssertionExpression(node), true, message);
 }
-export function isAssertsKeyword(node, message = "node is not a AssertsKeyword") {
+export function isAssertsKeyword(node, message = `expected AssertsKeyword, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isAssertsKeyword(node), true, message);
 }
-export function isAsteriskToken(node, message = "node is not a AsteriskToken") {
+export function isAsteriskToken(node, message = `expected AsteriskToken, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isAsteriskToken(node), true, message);
 }
-export function isAutoAccessorPropertyDeclaration(node, message = "node is not a AutoAccessorPropertyDeclaration") {
+export function isAutoAccessorPropertyDeclaration(node, message = `expected AutoAccessorPropertyDeclaration, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isAutoAccessorPropertyDeclaration(node), true, message);
 }
-export function isAwaitExpression(node, message = "node is not a AwaitExpression") {
+export function isAwaitExpression(node, message = `expected AwaitExpression, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isAwaitExpression(node), true, message);
 }
-export function isAwaitKeyword(node, message = "node is not a AwaitKeyword") {
+export function isAwaitKeyword(node, message = `expected AwaitKeyword, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isAwaitKeyword(node), true, message);
 }
-export function isBigIntLiteral(node, message = "node is not a BigIntLiteral") {
+export function isBigIntLiteral(node, message = `expected BigIntLiteral, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isBigIntLiteral(node), true, message);
 }
-export function isBinaryExpression(node, message = "node is not a BinaryExpression") {
+export function isBinaryExpression(node, message = `expected BinaryExpression, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isBinaryExpression(node), true, message);
 }
-export function isBinaryOperatorToken(node, message = "node is not a BinaryOperatorToken") {
+export function isBinaryOperatorToken(node, message = `expected BinaryOperatorToken, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isBinaryOperatorToken(node), true, message);
 }
-export function isBindingElement(node, message = "node is not a BindingElement") {
+export function isBindingElement(node, message = `expected BindingElement, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isBindingElement(node), true, message);
 }
-export function isBindingName(node, message = "node is not a BindingName") {
+export function isBindingName(node, message = `expected BindingName, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isBindingName(node), true, message);
 }
-export function isBlock(node, message = "node is not a Block") {
+export function isBlock(node, message = `expected Block, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isBlock(node), true, message);
 }
-export function isBreakOrContinueStatement(node, message = "node is not a BreakOrContinueStatement") {
+export function isBreakOrContinueStatement(node, message = `expected BreakOrContinueStatement, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isBreakOrContinueStatement(node), true, message);
 }
-export function isBreakStatement(node, message = "node is not a BreakStatement") {
+export function isBreakStatement(node, message = `expected BreakStatement, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isBreakStatement(node), true, message);
 }
-export function isBundle(node, message = "node is not a Bundle") {
+export function isBundle(node, message = `expected Bundle, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isBundle(node), true, message);
 }
-export function isCallChain(node, message = "node is not a CallChain") {
+export function isCallChain(node, message = `expected CallChain, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isCallChain(node), true, message);
 }
-export function isCallExpression(node, message = "node is not a CallExpression") {
+export function isCallExpression(node, message = `expected CallExpression, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isCallExpression(node), true, message);
 }
-export function isCallLikeExpression(node, message = "node is not a CallLikeExpression") {
+export function isCallLikeExpression(node, message = `expected CallLikeExpression, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isCallLikeExpression(node), true, message);
 }
-export function isCallSignatureDeclaration(node, message = "node is not a CallSignatureDeclaration") {
+export function isCallSignatureDeclaration(node, message = `expected CallSignatureDeclaration, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isCallSignatureDeclaration(node), true, message);
 }
-export function isCaseBlock(node, message = "node is not a CaseBlock") {
+export function isCaseBlock(node, message = `expected CaseBlock, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isCaseBlock(node), true, message);
 }
-export function isCaseClause(node, message = "node is not a CaseClause") {
+export function isCaseClause(node, message = `expected CaseClause, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isCaseClause(node), true, message);
 }
-export function isCaseOrDefaultClause(node, message = "node is not a CaseOrDefaultClause") {
+export function isCaseOrDefaultClause(node, message = `expected CaseOrDefaultClause, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isCaseOrDefaultClause(node), true, message);
 }
-export function isCatchClause(node, message = "node is not a CatchClause") {
+export function isCatchClause(node, message = `expected CatchClause, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isCatchClause(node), true, message);
 }
-export function isClassDeclaration(node, message = "node is not a ClassDeclaration") {
+export function isClassDeclaration(node, message = `expected ClassDeclaration, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isClassDeclaration(node), true, message);
 }
-export function isClassElement(node, message = "node is not a ClassElement") {
+export function isClassElement(node, message = `expected ClassElement, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isClassElement(node), true, message);
 }
-export function isClassExpression(node, message = "node is not a ClassExpression") {
+export function isClassExpression(node, message = `expected ClassExpression, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isClassExpression(node), true, message);
 }
-export function isClassLike(node, message = "node is not a ClassLikeDeclaration") {
+export function isClassLike(node, message = `expected ClassLikeDeclaration, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isClassLike(node), true, message);
 }
-export function isClassStaticBlockDeclaration(node, message = "node is not a ClassStaticBlockDeclaration") {
+export function isClassStaticBlockDeclaration(node, message = `expected ClassStaticBlockDeclaration, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isClassStaticBlockDeclaration(node), true, message);
 }
-export function isColonToken(node, message = "node is not a ColonToken") {
+export function isColonToken(node, message = `expected ColonToken, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isColonToken(node), true, message);
 }
-export function isCommaListExpression(node, message = "node is not a CommaListExpression") {
+export function isCommaListExpression(node, message = `expected CommaListExpression, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isCommaListExpression(node), true, message);
 }
-export function isComputedPropertyName(node, message = "node is not a ComputedPropertyName") {
+export function isComputedPropertyName(node, message = `expected ComputedPropertyName, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isComputedPropertyName(node), true, message);
 }
-export function isConciseBody(node, message = "node is not a ConciseBody") {
+export function isConciseBody(node, message = `expected ConciseBody, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isConciseBody(node), true, message);
 }
-export function isConditionalExpression(node, message = "node is not a ConditionalExpression") {
+export function isConditionalExpression(node, message = `expected ConditionalExpression, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isConditionalExpression(node), true, message);
 }
-export function isConditionalTypeNode(node, message = "node is not a ConditionalTypeNode") {
+export function isConditionalTypeNode(node, message = `expected ConditionalTypeNode, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isConditionalTypeNode(node), true, message);
 }
-export function isConstructorDeclaration(node, message = "node is not a ConstructorDeclaration") {
+export function isConstructorDeclaration(node, message = `expected ConstructorDeclaration, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isConstructorDeclaration(node), true, message);
 }
-export function isConstructorTypeNode(node, message = "node is not a ConstructorTypeNode") {
+export function isConstructorTypeNode(node, message = `expected ConstructorTypeNode, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isConstructorTypeNode(node), true, message);
 }
-export function isConstructSignatureDeclaration(node, message = "node is not a ConstructSignatureDeclaration") {
+export function isConstructSignatureDeclaration(node, message = `expected ConstructSignatureDeclaration, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isConstructSignatureDeclaration(node), true, message);
 }
-export function isContinueStatement(node, message = "node is not a ContinueStatement") {
+export function isContinueStatement(node, message = `expected ContinueStatement, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isContinueStatement(node), true, message);
 }
-export function isDebuggerStatement(node, message = "node is not a DebuggerStatement") {
+export function isDebuggerStatement(node, message = `expected DebuggerStatement, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isDebuggerStatement(node), true, message);
 }
-export function isDeclarationStatement(node, message = "node is not a DeclarationStatement") {
+export function isDeclarationStatement(node, message = `expected DeclarationStatement, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isDeclarationStatement(node), true, message);
 }
-export function isDecorator(node, message = "node is not a Decorator") {
+export function isDecorator(node, message = `expected Decorator, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isDecorator(node), true, message);
 }
-export function isDefaultClause(node, message = "node is not a DefaultClause") {
+export function isDefaultClause(node, message = `expected DefaultClause, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isDefaultClause(node), true, message);
 }
-export function isDeleteExpression(node, message = "node is not a DeleteExpression") {
+export function isDeleteExpression(node, message = `expected DeleteExpression, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isDeleteExpression(node), true, message);
 }
-export function isDoStatement(node, message = "node is not a DoStatement") {
+export function isDoStatement(node, message = `expected DoStatement, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isDoStatement(node), true, message);
 }
-export function isDotDotDotToken(node, message = "node is not a DotDotDotToken") {
+export function isDotDotDotToken(node, message = `expected DotDotDotToken, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isDotDotDotToken(node), true, message);
 }
-export function isElementAccessChain(node, message = "node is not a ElementAccessChain") {
+export function isElementAccessChain(node, message = `expected ElementAccessChain, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isElementAccessChain(node), true, message);
 }
-export function isElementAccessExpression(node, message = "node is not a ElementAccessExpression") {
+export function isElementAccessExpression(node, message = `expected ElementAccessExpression, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isElementAccessExpression(node), true, message);
 }
-export function isEmptyBindingPattern(node, message = "node is not a BindingPattern") {
+export function isEmptyBindingPattern(node, message = `expected BindingPattern, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isEmptyBindingPattern(node), true, message);
 }
-export function isEmptyStatement(node, message = "node is not a EmptyStatement") {
+export function isEmptyStatement(node, message = `expected EmptyStatement, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isEmptyStatement(node), true, message);
 }
-export function isEntityName(node, message = "node is not a EntityName") {
+export function isEntityName(node, message = `expected EntityName, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isEntityName(node), true, message);
 }
-export function isEnumDeclaration(node, message = "node is not a EnumDeclaration") {
+export function isEnumDeclaration(node, message = `expected EnumDeclaration, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isEnumDeclaration(node), true, message);
 }
-export function isEnumMember(node, message = "node is not a EnumMember") {
+export function isEnumMember(node, message = `expected EnumMember, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isEnumMember(node), true, message);
 }
-export function isEqualsGreaterThanToken(node, message = "node is not a EqualsGreaterThanToken") {
+export function isEqualsGreaterThanToken(node, message = `expected EqualsGreaterThanToken, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isEqualsGreaterThanToken(node), true, message);
 }
-export function isExclamationToken(node, message = "node is not a ExclamationToken") {
+export function isExclamationToken(node, message = `expected ExclamationToken, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isExclamationToken(node), true, message);
 }
-export function isExportAssignment(node, message = "node is not a ExportAssignment") {
+export function isExportAssignment(node, message = `expected ExportAssignment, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isExportAssignment(node), true, message);
 }
-export function isExportDeclaration(node, message = "node is not a ExportDeclaration") {
+export function isExportDeclaration(node, message = `expected ExportDeclaration, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isExportDeclaration(node), true, message);
 }
-export function isExportSpecifier(node, message = "node is not a ExportSpecifier") {
+export function isExportSpecifier(node, message = `expected ExportSpecifier, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isExportSpecifier(node), true, message);
 }
-export function isExpression(node, message = "node is not a Expression") {
+export function isExpression(node, message = `expected Expression, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isExpression(node), true, message);
 }
-export function isExpressionStatement(node, message = "node is not a ExpressionStatement") {
+export function isExpressionStatement(node, message = `expected ExpressionStatement, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isExpressionStatement(node), true, message);
 }
-export function isExpressionWithTypeArguments(node, message = "node is not a ExpressionWithTypeArguments") {
+export function isExpressionWithTypeArguments(node, message = `expected ExpressionWithTypeArguments, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isExpressionWithTypeArguments(node), true, message);
 }
-export function isExternalModuleReference(node, message = "node is not a ExternalModuleReference") {
+export function isExternalModuleReference(node, message = `expected ExternalModuleReference, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isExternalModuleReference(node), true, message);
 }
-export function isForInitializer(node, message = "node is not a ForInitializer") {
+export function isForInitializer(node, message = `expected ForInitializer, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isForInitializer(node), true, message);
 }
-export function isForInStatement(node, message = "node is not a ForInStatement") {
+export function isForInStatement(node, message = `expected ForInStatement, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isForInStatement(node), true, message);
 }
-export function isForOfStatement(node, message = "node is not a ForOfStatement") {
+export function isForOfStatement(node, message = `expected ForOfStatement, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isForOfStatement(node), true, message);
 }
-export function isForStatement(node, message = "node is not a ForStatement") {
+export function isForStatement(node, message = `expected ForStatement, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isForStatement(node), true, message);
 }
-export function isFunctionDeclaration(node, message = "node is not a FunctionDeclaration") {
+export function isFunctionDeclaration(node, message = `expected FunctionDeclaration, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isFunctionDeclaration(node), true, message);
 }
-export function isFunctionExpression(node, message = "node is not a FunctionExpression") {
+export function isFunctionExpression(node, message = `expected FunctionExpression, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isFunctionExpression(node), true, message);
 }
-export function isFunctionTypeNode(node, message = "node is not a FunctionTypeNode") {
+export function isFunctionTypeNode(node, message = `expected FunctionTypeNode, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isFunctionTypeNode(node), true, message);
 }
-export function isGetAccessor(node, message = "node is not a GetAccessorDeclaration") {
+export function isGetAccessor(node, message = `expected GetAccessorDeclaration, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isGetAccessor(node), true, message);
 }
-export function isGetAccessorDeclaration(node, message = "node is not a GetAccessorDeclaration") {
+export function isGetAccessorDeclaration(node, message = `expected GetAccessorDeclaration, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isGetAccessorDeclaration(node), true, message);
 }
-export function isHeritageClause(node, message = "node is not a HeritageClause") {
+export function isHeritageClause(node, message = `expected HeritageClause, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isHeritageClause(node), true, message);
 }
-export function isIdentifier(node, message = "node is not a Identifier") {
+export function isIdentifier(node, message = `expected Identifier, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isIdentifier(node), true, message);
 }
-export function isIfStatement(node, message = "node is not a IfStatement") {
+export function isIfStatement(node, message = `expected IfStatement, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isIfStatement(node), true, message);
 }
-export function isImportAttribute(node, message = "node is not a ImportAttribute") {
+export function isImportAttribute(node, message = `expected ImportAttribute, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isImportAttribute(node), true, message);
 }
-export function isImportAttributeName(node, message = "node is not a ImportAttributeName") {
+export function isImportAttributeName(node, message = `expected ImportAttributeName, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isImportAttributeName(node), true, message);
 }
-export function isImportAttributes(node, message = "node is not a ImportAttributes") {
+export function isImportAttributes(node, message = `expected ImportAttributes, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isImportAttributes(node), true, message);
 }
-export function isImportClause(node, message = "node is not a ImportClause") {
+export function isImportClause(node, message = `expected ImportClause, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isImportClause(node), true, message);
 }
-export function isImportDeclaration(node, message = "node is not a ImportDeclaration") {
+export function isImportDeclaration(node, message = `expected ImportDeclaration, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isImportDeclaration(node), true, message);
 }
-export function isImportEqualsDeclaration(node, message = "node is not a ImportEqualsDeclaration") {
+export function isImportEqualsDeclaration(node, message = `expected ImportEqualsDeclaration, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isImportEqualsDeclaration(node), true, message);
 }
-export function isImportSpecifier(node, message = "node is not a ImportSpecifier") {
+export function isImportSpecifier(node, message = `expected ImportSpecifier, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isImportSpecifier(node), true, message);
 }
-export function isImportTypeNode(node, message = "node is not a ImportTypeNode") {
+export function isImportTypeNode(node, message = `expected ImportTypeNode, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isImportTypeNode(node), true, message);
 }
-export function isIndexedAccessTypeNode(node, message = "node is not a IndexedAccessTypeNode") {
+export function isIndexedAccessTypeNode(node, message = `expected IndexedAccessTypeNode, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isIndexedAccessTypeNode(node), true, message);
 }
-export function isIndexSignatureDeclaration(node, message = "node is not a IndexSignatureDeclaration") {
+export function isIndexSignatureDeclaration(node, message = `expected IndexSignatureDeclaration, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isIndexSignatureDeclaration(node), true, message);
 }
-export function isInferTypeNode(node, message = "node is not a InferTypeNode") {
+export function isInferTypeNode(node, message = `expected InferTypeNode, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isInferTypeNode(node), true, message);
 }
-export function isInterfaceDeclaration(node, message = "node is not a InterfaceDeclaration") {
+export function isInterfaceDeclaration(node, message = `expected InterfaceDeclaration, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isInterfaceDeclaration(node), true, message);
 }
-export function isIntersectionTypeNode(node, message = "node is not a IntersectionTypeNode") {
+export function isIntersectionTypeNode(node, message = `expected IntersectionTypeNode, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isIntersectionTypeNode(node), true, message);
 }
-export function isJSDoc(node, message = "node is not a JSDoc") {
+export function isJSDoc(node, message = `expected JSDoc, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isJSDoc(node), true, message);
 }
-export function isJSDocAllType(node, message = "node is not a JSDocAllType") {
+export function isJSDocAllType(node, message = `expected JSDocAllType, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isJSDocAllType(node), true, message);
 }
-export function isJSDocAugmentsTag(node, message = "node is not a JSDocAugmentsTag") {
+export function isJSDocAugmentsTag(node, message = `expected JSDocAugmentsTag, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isJSDocAugmentsTag(node), true, message);
 }
-export function isJSDocAuthorTag(node, message = "node is not a JSDocAuthorTag") {
+export function isJSDocAuthorTag(node, message = `expected JSDocAuthorTag, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isJSDocAuthorTag(node), true, message);
 }
-export function isJSDocCallbackTag(node, message = "node is not a JSDocCallbackTag") {
+export function isJSDocCallbackTag(node, message = `expected JSDocCallbackTag, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isJSDocCallbackTag(node), true, message);
 }
-export function isJSDocClassTag(node, message = "node is not a JSDocClassTag") {
+export function isJSDocClassTag(node, message = `expected JSDocClassTag, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isJSDocClassTag(node), true, message);
 }
-export function isJSDocDeprecatedTag(node, message = "node is not a JSDocDeprecatedTag") {
+export function isJSDocDeprecatedTag(node, message = `expected JSDocDeprecatedTag, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isJSDocDeprecatedTag(node), true, message);
 }
-export function isJSDocEnumTag(node, message = "node is not a JSDocEnumTag") {
+export function isJSDocEnumTag(node, message = `expected JSDocEnumTag, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isJSDocEnumTag(node), true, message);
 }
-export function isJSDocFunctionType(node, message = "node is not a JSDocFunctionType") {
+export function isJSDocFunctionType(node, message = `expected JSDocFunctionType, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isJSDocFunctionType(node), true, message);
 }
-export function isJSDocImplementsTag(node, message = "node is not a JSDocImplementsTag") {
+export function isJSDocImplementsTag(node, message = `expected JSDocImplementsTag, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isJSDocImplementsTag(node), true, message);
 }
-export function isJSDocLink(node, message = "node is not a JSDocLink") {
+export function isJSDocLink(node, message = `expected JSDocLink, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isJSDocLink(node), true, message);
 }
-export function isJSDocLinkCode(node, message = "node is not a JSDocLinkCode") {
+export function isJSDocLinkCode(node, message = `expected JSDocLinkCode, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isJSDocLinkCode(node), true, message);
 }
-export function isJSDocLinkPlain(node, message = "node is not a JSDocLinkPlain") {
+export function isJSDocLinkPlain(node, message = `expected JSDocLinkPlain, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isJSDocLinkPlain(node), true, message);
 }
-export function isJSDocMemberName(node, message = "node is not a JSDocMemberName") {
+export function isJSDocMemberName(node, message = `expected JSDocMemberName, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isJSDocMemberName(node), true, message);
 }
-export function isJSDocNamepathType(node, message = "node is not a JSDocNamepathType") {
+export function isJSDocNamepathType(node, message = `expected JSDocNamepathType, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isJSDocNamepathType(node), true, message);
 }
-export function isJSDocNameReference(node, message = "node is not a JSDocNameReference") {
+export function isJSDocNameReference(node, message = `expected JSDocNameReference, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isJSDocNameReference(node), true, message);
 }
-export function isJSDocNonNullableType(node, message = "node is not a JSDocNonNullableType") {
+export function isJSDocNonNullableType(node, message = `expected JSDocNonNullableType, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isJSDocNonNullableType(node), true, message);
 }
-export function isJSDocNullableType(node, message = "node is not a JSDocNullableType") {
+export function isJSDocNullableType(node, message = `expected JSDocNullableType, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isJSDocNullableType(node), true, message);
 }
-export function isJSDocOptionalType(node, message = "node is not a JSDocOptionalType") {
+export function isJSDocOptionalType(node, message = `expected JSDocOptionalType, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isJSDocOptionalType(node), true, message);
 }
-export function isJSDocOverloadTag(node, message = "node is not a JSDocOverloadTag") {
+export function isJSDocOverloadTag(node, message = `expected JSDocOverloadTag, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isJSDocOverloadTag(node), true, message);
 }
-export function isJSDocOverrideTag(node, message = "node is not a JSDocOverrideTag") {
+export function isJSDocOverrideTag(node, message = `expected JSDocOverrideTag, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isJSDocOverrideTag(node), true, message);
 }
-export function isJSDocParameterTag(node, message = "node is not a JSDocParameterTag") {
+export function isJSDocParameterTag(node, message = `expected JSDocParameterTag, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isJSDocParameterTag(node), true, message);
 }
-export function isJSDocPrivateTag(node, message = "node is not a JSDocPrivateTag") {
+export function isJSDocPrivateTag(node, message = `expected JSDocPrivateTag, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isJSDocPrivateTag(node), true, message);
 }
-export function isJSDocPropertyLikeTag(node, message = "node is not a JSDocPropertyLikeTag") {
+export function isJSDocPropertyLikeTag(node, message = `expected JSDocPropertyLikeTag, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isJSDocPropertyLikeTag(node), true, message);
 }
-export function isJSDocPropertyTag(node, message = "node is not a JSDocPropertyTag") {
+export function isJSDocPropertyTag(node, message = `expected JSDocPropertyTag, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isJSDocPropertyTag(node), true, message);
 }
-export function isJSDocProtectedTag(node, message = "node is not a JSDocProtectedTag") {
+export function isJSDocProtectedTag(node, message = `expected JSDocProtectedTag, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isJSDocProtectedTag(node), true, message);
 }
-export function isJSDocPublicTag(node, message = "node is not a JSDocPublicTag") {
+export function isJSDocPublicTag(node, message = `expected JSDocPublicTag, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isJSDocPublicTag(node), true, message);
 }
-export function isJSDocReadonlyTag(node, message = "node is not a JSDocReadonlyTag") {
+export function isJSDocReadonlyTag(node, message = `expected JSDocReadonlyTag, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isJSDocReadonlyTag(node), true, message);
 }
-export function isJSDocReturnTag(node, message = "node is not a JSDocReturnTag") {
+export function isJSDocReturnTag(node, message = `expected JSDocReturnTag, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isJSDocReturnTag(node), true, message);
 }
-export function isJSDocSatisfiesTag(node, message = "node is not a JSDocSatisfiesTag") {
+export function isJSDocSatisfiesTag(node, message = `expected JSDocSatisfiesTag, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isJSDocSatisfiesTag(node), true, message);
 }
-export function isJSDocSeeTag(node, message = "node is not a JSDocSeeTag") {
+export function isJSDocSeeTag(node, message = `expected JSDocSeeTag, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isJSDocSeeTag(node), true, message);
 }
-export function isJSDocSignature(node, message = "node is not a JSDocSignature") {
+export function isJSDocSignature(node, message = `expected JSDocSignature, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isJSDocSignature(node), true, message);
 }
-export function isJSDocTemplateTag(node, message = "node is not a JSDocTemplateTag") {
+export function isJSDocTemplateTag(node, message = `expected JSDocTemplateTag, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isJSDocTemplateTag(node), true, message);
 }
-export function isJSDocThisTag(node, message = "node is not a JSDocThisTag") {
+export function isJSDocThisTag(node, message = `expected JSDocThisTag, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isJSDocThisTag(node), true, message);
 }
-export function isJSDocThrowsTag(node, message = "node is not a JSDocThrowsTag") {
+export function isJSDocThrowsTag(node, message = `expected JSDocThrowsTag, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isJSDocThrowsTag(node), true, message);
 }
-export function isJSDocTypedefTag(node, message = "node is not a JSDocTypedefTag") {
+export function isJSDocTypedefTag(node, message = `expected JSDocTypedefTag, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isJSDocTypedefTag(node), true, message);
 }
-export function isJSDocTypeExpression(node, message = "node is not a JSDocTypeExpression") {
+export function isJSDocTypeExpression(node, message = `expected JSDocTypeExpression, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isJSDocTypeExpression(node), true, message);
 }
-export function isJSDocTypeLiteral(node, message = "node is not a JSDocTypeLiteral") {
+export function isJSDocTypeLiteral(node, message = `expected JSDocTypeLiteral, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isJSDocTypeLiteral(node), true, message);
 }
-export function isJSDocTypeTag(node, message = "node is not a JSDocTypeTag") {
+export function isJSDocTypeTag(node, message = `expected JSDocTypeTag, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isJSDocTypeTag(node), true, message);
 }
-export function isJSDocUnknownTag(node, message = "node is not a JSDocUnknownTag") {
+export function isJSDocUnknownTag(node, message = `expected JSDocUnknownTag, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isJSDocUnknownTag(node), true, message);
 }
-export function isJSDocUnknownType(node, message = "node is not a JSDocUnknownType") {
+export function isJSDocUnknownType(node, message = `expected JSDocUnknownType, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isJSDocUnknownType(node), true, message);
 }
-export function isJSDocVariadicType(node, message = "node is not a JSDocVariadicType") {
+export function isJSDocVariadicType(node, message = `expected JSDocVariadicType, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isJSDocVariadicType(node), true, message);
 }
-export function isJsxAttribute(node, message = "node is not a JsxAttribute") {
+export function isJsxAttribute(node, message = `expected JsxAttribute, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isJsxAttribute(node), true, message);
 }
-export function isJsxAttributeLike(node, message = "node is not a JsxAttributeLike") {
+export function isJsxAttributeLike(node, message = `expected JsxAttributeLike, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isJsxAttributeLike(node), true, message);
 }
-export function isJsxAttributes(node, message = "node is not a JsxAttributes") {
+export function isJsxAttributes(node, message = `expected JsxAttributes, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isJsxAttributes(node), true, message);
 }
-export function isJsxChild(node, message = "node is not a JsxChild") {
+export function isJsxChild(node, message = `expected JsxChild, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isJsxChild(node), true, message);
 }
-export function isJsxClosingElement(node, message = "node is not a JsxClosingElement") {
+export function isJsxClosingElement(node, message = `expected JsxClosingElement, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isJsxClosingElement(node), true, message);
 }
-export function isJsxClosingFragment(node, message = "node is not a JsxClosingFragment") {
+export function isJsxClosingFragment(node, message = `expected JsxClosingFragment, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isJsxClosingFragment(node), true, message);
 }
-export function isJsxElement(node, message = "node is not a JsxElement") {
+export function isJsxElement(node, message = `expected JsxElement, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isJsxElement(node), true, message);
 }
-export function isJsxExpression(node, message = "node is not a JsxExpression") {
+export function isJsxExpression(node, message = `expected JsxExpression, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isJsxExpression(node), true, message);
 }
-export function isJsxFragment(node, message = "node is not a JsxFragment") {
+export function isJsxFragment(node, message = `expected JsxFragment, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isJsxFragment(node), true, message);
 }
-export function isJsxNamespacedName(node, message = "node is not a JsxNamespacedName") {
+export function isJsxNamespacedName(node, message = `expected JsxNamespacedName, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isJsxNamespacedName(node), true, message);
 }
-export function isJsxOpeningElement(node, message = "node is not a JsxOpeningElement") {
+export function isJsxOpeningElement(node, message = `expected JsxOpeningElement, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isJsxOpeningElement(node), true, message);
 }
-export function isJsxOpeningFragment(node, message = "node is not a JsxOpeningFragment") {
+export function isJsxOpeningFragment(node, message = `expected JsxOpeningFragment, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isJsxOpeningFragment(node), true, message);
 }
-export function isJsxOpeningLikeElement(node, message = "node is not a JsxOpeningLikeElement") {
+export function isJsxOpeningLikeElement(node, message = `expected JsxOpeningLikeElement, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isJsxOpeningLikeElement(node), true, message);
 }
-export function isJsxSelfClosingElement(node, message = "node is not a JsxSelfClosingElement") {
+export function isJsxSelfClosingElement(node, message = `expected JsxSelfClosingElement, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isJsxSelfClosingElement(node), true, message);
 }
-export function isJsxSpreadAttribute(node, message = "node is not a JsxSpreadAttribute") {
+export function isJsxSpreadAttribute(node, message = `expected JsxSpreadAttribute, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isJsxSpreadAttribute(node), true, message);
 }
-export function isJsxTagNameExpression(node, message = "node is not a JsxTagNameExpression") {
+export function isJsxTagNameExpression(node, message = `expected JsxTagNameExpression, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isJsxTagNameExpression(node), true, message);
 }
-export function isJsxText(node, message = "node is not a JsxText") {
+export function isJsxText(node, message = `expected JsxText, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isJsxText(node), true, message);
 }
-export function isLabeledStatement(node, message = "node is not a LabeledStatement") {
+export function isLabeledStatement(node, message = `expected LabeledStatement, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isLabeledStatement(node), true, message);
 }
-export function isLeftHandSideExpression(node, message = "node is not a LeftHandSideExpression") {
+export function isLeftHandSideExpression(node, message = `expected LeftHandSideExpression, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isLeftHandSideExpression(node), true, message);
 }
-export function isLiteralExpression(node, message = "node is not a LiteralExpression") {
+export function isLiteralExpression(node, message = `expected LiteralExpression, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isLiteralExpression(node), true, message);
 }
-export function isLiteralTypeNode(node, message = "node is not a LiteralTypeNode") {
+export function isLiteralTypeNode(node, message = `expected LiteralTypeNode, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isLiteralTypeNode(node), true, message);
 }
-export function isMappedTypeNode(node, message = "node is not a MappedTypeNode") {
+export function isMappedTypeNode(node, message = `expected MappedTypeNode, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isMappedTypeNode(node), true, message);
 }
-export function isMemberName(node, message = "node is not a MemberName") {
+export function isMemberName(node, message = `expected MemberName, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isMemberName(node), true, message);
 }
-export function isMetaProperty(node, message = "node is not a MetaProperty") {
+export function isMetaProperty(node, message = `expected MetaProperty, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isMetaProperty(node), true, message);
 }
-export function isMethodDeclaration(node, message = "node is not a MethodDeclaration") {
+export function isMethodDeclaration(node, message = `expected MethodDeclaration, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isMethodDeclaration(node), true, message);
 }
-export function isMethodSignature(node, message = "node is not a MethodSignature") {
+export function isMethodSignature(node, message = `expected MethodSignature, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isMethodSignature(node), true, message);
 }
-export function isMinusToken(node, message = "node is not a MinusToken") {
+export function isMinusToken(node, message = `expected MinusToken, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isMinusToken(node), true, message);
 }
-export function isMissingDeclaration(node, message = "node is not a MissingDeclaration") {
+export function isMissingDeclaration(node, message = `expected MissingDeclaration, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isMissingDeclaration(node), true, message);
 }
-export function isModifier(node, message = "node is not a Modifier") {
+export function isModifier(node, message = `expected Modifier, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isModifier(node), true, message);
 }
-export function isModifierLike(node, message = "node is not a ModifierLike") {
+export function isModifierLike(node, message = `expected ModifierLike, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isModifierLike(node), true, message);
 }
-export function isModuleBlock(node, message = "node is not a ModuleBlock") {
+export function isModuleBlock(node, message = `expected ModuleBlock, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isModuleBlock(node), true, message);
 }
-export function isModuleBody(node, message = "node is not a ModuleBody") {
+export function isModuleBody(node, message = `expected ModuleBody, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isModuleBody(node), true, message);
 }
-export function isModuleDeclaration(node, message = "node is not a ModuleDeclaration") {
+export function isModuleDeclaration(node, message = `expected ModuleDeclaration, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isModuleDeclaration(node), true, message);
 }
-export function isModuleName(node, message = "node is not a ModuleName") {
+export function isModuleName(node, message = `expected ModuleName, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isModuleName(node), true, message);
 }
-export function isModuleReference(node, message = "node is not a ModuleReference") {
+export function isModuleReference(node, message = `expected ModuleReference, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isModuleReference(node), true, message);
 }
-export function isNamedExportBindings(node, message = "node is not a NamedExportBindings") {
+export function isNamedExportBindings(node, message = `expected NamedExportBindings, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isNamedExportBindings(node), true, message);
 }
-export function isNamedExports(node, message = "node is not a NamedExports") {
+export function isNamedExports(node, message = `expected NamedExports, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isNamedExports(node), true, message);
 }
-export function isNamedImportBindings(node, message = "node is not a NamedImportBindings") {
+export function isNamedImportBindings(node, message = `expected NamedImportBindings, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isNamedImportBindings(node), true, message);
 }
-export function isNamedImports(node, message = "node is not a NamedImports") {
+export function isNamedImports(node, message = `expected NamedImports, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isNamedImports(node), true, message);
 }
-export function isNamedTupleMember(node, message = "node is not a NamedTupleMember") {
+export function isNamedTupleMember(node, message = `expected NamedTupleMember, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isNamedTupleMember(node), true, message);
 }
-export function isNamespaceExport(node, message = "node is not a NamespaceExport") {
+export function isNamespaceExport(node, message = `expected NamespaceExport, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isNamespaceExport(node), true, message);
 }
-export function isNamespaceExportDeclaration(node, message = "node is not a NamespaceExportDeclaration") {
+export function isNamespaceExportDeclaration(node, message = `expected NamespaceExportDeclaration, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isNamespaceExportDeclaration(node), true, message);
 }
-export function isNamespaceImport(node, message = "node is not a NamespaceImport") {
+export function isNamespaceImport(node, message = `expected NamespaceImport, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isNamespaceImport(node), true, message);
 }
-export function isNewExpression(node, message = "node is not a NewExpression") {
+export function isNewExpression(node, message = `expected NewExpression, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isNewExpression(node), true, message);
 }
-export function isNonNullChain(node, message = "node is not a NonNullChain") {
+export function isNonNullChain(node, message = `expected NonNullChain, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isNonNullChain(node), true, message);
 }
-export function isNonNullExpression(node, message = "node is not a NonNullExpression") {
+export function isNonNullExpression(node, message = `expected NonNullExpression, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isNonNullExpression(node), true, message);
 }
-export function isNoSubstitutionTemplateLiteral(node, message = "node is not a NoSubstitutionTemplateLiteral") {
+export function isNoSubstitutionTemplateLiteral(node, message = `expected NoSubstitutionTemplateLiteral, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isNoSubstitutionTemplateLiteral(node), true, message);
 }
-export function isNotEmittedStatement(node, message = "node is not a NotEmittedStatement") {
+export function isNotEmittedStatement(node, message = `expected NotEmittedStatement, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isNotEmittedStatement(node), true, message);
 }
-export function isNumericLiteral(node, message = "node is not a NumericLiteral") {
+export function isNumericLiteral(node, message = `expected NumericLiteral, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isNumericLiteral(node), true, message);
 }
-export function isObjectBindingPattern(node, message = "node is not a ObjectBindingPattern") {
+export function isObjectBindingPattern(node, message = `expected ObjectBindingPattern, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isObjectBindingPattern(node), true, message);
 }
-export function isObjectLiteralElement(node, message = "node is not a ObjectLiteralElement") {
+export function isObjectLiteralElement(node, message = `expected ObjectLiteralElement, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isObjectLiteralElement(node), true, message);
 }
-export function isObjectLiteralElementLike(node, message = "node is not a ObjectLiteralElementLike") {
+export function isObjectLiteralElementLike(node, message = `expected ObjectLiteralElementLike, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isObjectLiteralElementLike(node), true, message);
 }
-export function isObjectLiteralExpression(node, message = "node is not a ObjectLiteralExpression") {
+export function isObjectLiteralExpression(node, message = `expected ObjectLiteralExpression, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isObjectLiteralExpression(node), true, message);
 }
-export function isOmittedExpression(node, message = "node is not a OmittedExpression") {
+export function isOmittedExpression(node, message = `expected OmittedExpression, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isOmittedExpression(node), true, message);
 }
-export function isOptionalTypeNode(node, message = "node is not a OptionalTypeNode") {
+export function isOptionalTypeNode(node, message = `expected OptionalTypeNode, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isOptionalTypeNode(node), true, message);
 }
-export function isParameter(node, message = "node is not a ParameterDeclaration") {
+export function isParameter(node, message = `expected ParameterDeclaration, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isParameter(node), true, message);
 }
-export function isParenthesizedExpression(node, message = "node is not a ParenthesizedExpression") {
+export function isParenthesizedExpression(node, message = `expected ParenthesizedExpression, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isParenthesizedExpression(node), true, message);
 }
-export function isParenthesizedTypeNode(node, message = "node is not a ParenthesizedTypeNode") {
+export function isParenthesizedTypeNode(node, message = `expected ParenthesizedTypeNode, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isParenthesizedTypeNode(node), true, message);
 }
-export function isPartiallyEmittedExpression(node, message = "node is not a PartiallyEmittedExpression") {
+export function isPartiallyEmittedExpression(node, message = `expected PartiallyEmittedExpression, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isPartiallyEmittedExpression(node), true, message);
 }
-export function isPlusToken(node, message = "node is not a PlusToken") {
+export function isPlusToken(node, message = `expected PlusToken, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isPlusToken(node), true, message);
 }
-export function isPostfixUnaryExpression(node, message = "node is not a PostfixUnaryExpression") {
+export function isPostfixUnaryExpression(node, message = `expected PostfixUnaryExpression, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isPostfixUnaryExpression(node), true, message);
 }
-export function isPrefixUnaryExpression(node, message = "node is not a PrefixUnaryExpression") {
+export function isPrefixUnaryExpression(node, message = `expected PrefixUnaryExpression, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isPrefixUnaryExpression(node), true, message);
 }
-export function isPrivateIdentifier(node, message = "node is not a PrivateIdentifier") {
+export function isPrivateIdentifier(node, message = `expected PrivateIdentifier, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isPrivateIdentifier(node), true, message);
 }
-export function isPropertyAccessChain(node, message = "node is not a PropertyAccessChain") {
+export function isPropertyAccessChain(node, message = `expected PropertyAccessChain, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isPropertyAccessChain(node), true, message);
 }
-export function isPropertyAccessExpression(node, message = "node is not a PropertyAccessExpression") {
+export function isPropertyAccessExpression(node, message = `expected PropertyAccessExpression, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isPropertyAccessExpression(node), true, message);
 }
-export function isPropertyAssignment(node, message = "node is not a PropertyAssignment") {
+export function isPropertyAssignment(node, message = `expected PropertyAssignment, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isPropertyAssignment(node), true, message);
 }
-export function isPropertyDeclaration(node, message = "node is not a PropertyDeclaration") {
+export function isPropertyDeclaration(node, message = `expected PropertyDeclaration, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isPropertyDeclaration(node), true, message);
 }
-export function isPropertyName(node, message = "node is not a PropertyName") {
+export function isPropertyName(node, message = `expected PropertyName, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isPropertyName(node), true, message);
 }
-export function isPropertySignature(node, message = "node is not a PropertySignature") {
+export function isPropertySignature(node, message = `expected PropertySignature, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isPropertySignature(node), true, message);
 }
-export function isQualifiedName(node, message = "node is not a QualifiedName") {
+export function isQualifiedName(node, message = `expected QualifiedName, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isQualifiedName(node), true, message);
 }
-export function isQuestionDotToken(node, message = "node is not a QuestionDotToken") {
+export function isQuestionDotToken(node, message = `expected QuestionDotToken, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isQuestionDotToken(node), true, message);
 }
-export function isQuestionToken(node, message = "node is not a QuestionToken") {
+export function isQuestionToken(node, message = `expected QuestionToken, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isQuestionToken(node), true, message);
 }
-export function isRegularExpressionLiteral(node, message = "node is not a RegularExpressionLiteral") {
+export function isRegularExpressionLiteral(node, message = `expected RegularExpressionLiteral, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isRegularExpressionLiteral(node), true, message);
 }
-export function isRestTypeNode(node, message = "node is not a RestTypeNode") {
+export function isRestTypeNode(node, message = `expected RestTypeNode, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isRestTypeNode(node), true, message);
 }
-export function isReturnStatement(node, message = "node is not a ReturnStatement") {
+export function isReturnStatement(node, message = `expected ReturnStatement, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isReturnStatement(node), true, message);
 }
-export function isSatisfiesExpression(node, message = "node is not a SatisfiesExpression") {
+export function isSatisfiesExpression(node, message = `expected SatisfiesExpression, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isSatisfiesExpression(node), true, message);
 }
-export function isSemicolonClassElement(node, message = "node is not a SemicolonClassElement") {
+export function isSemicolonClassElement(node, message = `expected SemicolonClassElement, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isSemicolonClassElement(node), true, message);
 }
-export function isSetAccessor(node, message = "node is not a SetAccessorDeclaration") {
+export function isSetAccessor(node, message = `expected SetAccessorDeclaration, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isSetAccessor(node), true, message);
 }
-export function isSetAccessorDeclaration(node, message = "node is not a SetAccessorDeclaration") {
+export function isSetAccessorDeclaration(node, message = `expected SetAccessorDeclaration, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isSetAccessorDeclaration(node), true, message);
 }
-export function isShorthandPropertyAssignment(node, message = "node is not a ShorthandPropertyAssignment") {
+export function isShorthandPropertyAssignment(node, message = `expected ShorthandPropertyAssignment, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isShorthandPropertyAssignment(node), true, message);
 }
-export function isSourceFile(node, message = "node is not a SourceFile") {
+export function isSourceFile(node, message = `expected SourceFile, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isSourceFile(node), true, message);
 }
-export function isSpreadAssignment(node, message = "node is not a SpreadAssignment") {
+export function isSpreadAssignment(node, message = `expected SpreadAssignment, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isSpreadAssignment(node), true, message);
 }
-export function isSpreadElement(node, message = "node is not a SpreadElement") {
+export function isSpreadElement(node, message = `expected SpreadElement, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isSpreadElement(node), true, message);
 }
-export function isStatement(node, message = "node is not a Statement") {
+export function isStatement(node, message = `expected Statement, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isStatement(node), true, message);
 }
-export function isStringLiteral(node, message = "node is not a StringLiteral") {
+export function isStringLiteral(node, message = `expected StringLiteral, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isStringLiteral(node), true, message);
 }
-export function isSwitchStatement(node, message = "node is not a SwitchStatement") {
+export function isSwitchStatement(node, message = `expected SwitchStatement, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isSwitchStatement(node), true, message);
 }
-export function isSyntheticExpression(node, message = "node is not a SyntheticExpression") {
+export function isSyntheticExpression(node, message = `expected SyntheticExpression, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isSyntheticExpression(node), true, message);
 }
-export function isTaggedTemplateExpression(node, message = "node is not a TaggedTemplateExpression") {
+export function isTaggedTemplateExpression(node, message = `expected TaggedTemplateExpression, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isTaggedTemplateExpression(node), true, message);
 }
-export function isTemplateExpression(node, message = "node is not a TemplateExpression") {
+export function isTemplateExpression(node, message = `expected TemplateExpression, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isTemplateExpression(node), true, message);
 }
-export function isTemplateHead(node, message = "node is not a TemplateHead") {
+export function isTemplateHead(node, message = `expected TemplateHead, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isTemplateHead(node), true, message);
 }
-export function isTemplateLiteral(node, message = "node is not a TemplateLiteral") {
+export function isTemplateLiteral(node, message = `expected TemplateLiteral, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isTemplateLiteral(node), true, message);
 }
-export function isTemplateLiteralToken(node, message = "node is not a TemplateLiteralToken") {
+export function isTemplateLiteralToken(node, message = `expected TemplateLiteralToken, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isTemplateLiteralToken(node), true, message);
 }
-export function isTemplateLiteralTypeNode(node, message = "node is not a TemplateLiteralTypeNode") {
+export function isTemplateLiteralTypeNode(node, message = `expected TemplateLiteralTypeNode, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isTemplateLiteralTypeNode(node), true, message);
 }
-export function isTemplateLiteralTypeSpan(node, message = "node is not a TemplateLiteralTypeSpan") {
+export function isTemplateLiteralTypeSpan(node, message = `expected TemplateLiteralTypeSpan, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isTemplateLiteralTypeSpan(node), true, message);
 }
-export function isTemplateMiddle(node, message = "node is not a TemplateMiddle") {
+export function isTemplateMiddle(node, message = `expected TemplateMiddle, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isTemplateMiddle(node), true, message);
 }
-export function isTemplateSpan(node, message = "node is not a TemplateSpan") {
+export function isTemplateSpan(node, message = `expected TemplateSpan, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isTemplateSpan(node), true, message);
 }
-export function isTemplateTail(node, message = "node is not a TemplateTail") {
+export function isTemplateTail(node, message = `expected TemplateTail, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isTemplateTail(node), true, message);
 }
-export function isThisTypeNode(node, message = "node is not a ThisTypeNode") {
+export function isThisTypeNode(node, message = `expected ThisTypeNode, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isThisTypeNode(node), true, message);
 }
-export function isThrowStatement(node, message = "node is not a ThrowStatement") {
+export function isThrowStatement(node, message = `expected ThrowStatement, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isThrowStatement(node), true, message);
 }
-export function isTryStatement(node, message = "node is not a TryStatement") {
+export function isTryStatement(node, message = `expected TryStatement, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isTryStatement(node), true, message);
 }
-export function isTupleTypeNode(node, message = "node is not a TupleTypeNode") {
+export function isTupleTypeNode(node, message = `expected TupleTypeNode, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isTupleTypeNode(node), true, message);
 }
-export function isTypeAliasDeclaration(node, message = "node is not a TypeAliasDeclaration") {
+export function isTypeAliasDeclaration(node, message = `expected TypeAliasDeclaration, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isTypeAliasDeclaration(node), true, message);
 }
-export function isTypeAssertionExpression(node, message = "node is not a TypeAssertion") {
+export function isTypeAssertionExpression(node, message = `expected TypeAssertion, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isTypeAssertionExpression(node), true, message);
 }
-export function isTypeElement(node, message = "node is not a TypeElement") {
+export function isTypeElement(node, message = `expected TypeElement, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isTypeElement(node), true, message);
 }
-export function isTypeLiteralNode(node, message = "node is not a TypeLiteralNode") {
+export function isTypeLiteralNode(node, message = `expected TypeLiteralNode, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isTypeLiteralNode(node), true, message);
 }
-export function isTypeNode(node, message = "node is not a TypeNode") {
+export function isTypeNode(node, message = `expected TypeNode, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isTypeNode(node), true, message);
 }
-export function isTypeOfExpression(node, message = "node is not a TypeOfExpression") {
+export function isTypeOfExpression(node, message = `expected TypeOfExpression, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isTypeOfExpression(node), true, message);
 }
-export function isTypeOnlyExportDeclaration(node, message = "node is not a TypeOnlyExportDeclaration") {
+export function isTypeOnlyExportDeclaration(node, message = `expected TypeOnlyExportDeclaration, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isTypeOnlyExportDeclaration(node), true, message);
 }
-export function isTypeOnlyImportDeclaration(node, message = "node is not a TypeOnlyImportDeclaration") {
+export function isTypeOnlyImportDeclaration(node, message = `expected TypeOnlyImportDeclaration, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isTypeOnlyImportDeclaration(node), true, message);
 }
-export function isTypeOnlyImportOrExportDeclaration(node, message = "node is not a TypeOnlyAliasDeclaration") {
+export function isTypeOnlyImportOrExportDeclaration(node, message = `expected TypeOnlyAliasDeclaration, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isTypeOnlyImportOrExportDeclaration(node), true, message);
 }
-export function isTypeOperatorNode(node, message = "node is not a TypeOperatorNode") {
+export function isTypeOperatorNode(node, message = `expected TypeOperatorNode, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isTypeOperatorNode(node), true, message);
 }
-export function isTypeParameterDeclaration(node, message = "node is not a TypeParameterDeclaration") {
+export function isTypeParameterDeclaration(node, message = `expected TypeParameterDeclaration, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isTypeParameterDeclaration(node), true, message);
 }
-export function isTypePredicateNode(node, message = "node is not a TypePredicateNode") {
+export function isTypePredicateNode(node, message = `expected TypePredicateNode, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isTypePredicateNode(node), true, message);
 }
-export function isTypeQueryNode(node, message = "node is not a TypeQueryNode") {
+export function isTypeQueryNode(node, message = `expected TypeQueryNode, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isTypeQueryNode(node), true, message);
 }
-export function isTypeReferenceNode(node, message = "node is not a TypeReferenceNode") {
+export function isTypeReferenceNode(node, message = `expected TypeReferenceNode, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isTypeReferenceNode(node), true, message);
 }
-export function isUnionTypeNode(node, message = "node is not a UnionTypeNode") {
+export function isUnionTypeNode(node, message = `expected UnionTypeNode, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isUnionTypeNode(node), true, message);
 }
-export function isVariableDeclaration(node, message = "node is not a VariableDeclaration") {
+export function isVariableDeclaration(node, message = `expected VariableDeclaration, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isVariableDeclaration(node), true, message);
 }
-export function isVariableDeclarationList(node, message = "node is not a VariableDeclarationList") {
+export function isVariableDeclarationList(node, message = `expected VariableDeclarationList, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isVariableDeclarationList(node), true, message);
 }
-export function isVariableStatement(node, message = "node is not a VariableStatement") {
+export function isVariableStatement(node, message = `expected VariableStatement, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isVariableStatement(node), true, message);
 }
-export function isVoidExpression(node, message = "node is not a VoidExpression") {
+export function isVoidExpression(node, message = `expected VoidExpression, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isVoidExpression(node), true, message);
 }
-export function isWhileStatement(node, message = "node is not a WhileStatement") {
+export function isWhileStatement(node, message = `expected WhileStatement, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isWhileStatement(node), true, message);
 }
-export function isWithStatement(node, message = "node is not a WithStatement") {
+export function isWithStatement(node, message = `expected WithStatement, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isWithStatement(node), true, message);
 }
-export function isYieldExpression(node, message = "node is not a YieldExpression") {
+export function isYieldExpression(node, message = `expected YieldExpression, received ${ts.SyntaxKind[node.kind]}`) {
     assert.equal(ts.isYieldExpression(node), true, message);
 }
 export default {

package/lib/main.d.ts

@@ -1,12 +1,20 @@
-import { isExpression } from '../generated/assertions';
-import ts, { FalseLiteral, Node, TrueLiteral, TypeNode } from 'typescript';
+import { isExpression, isIdentifier } from '../generated/assertions';
+import ts, { FalseLiteral, Identifier, Node, TrueLiteral, TypeNode } from 'typescript';
 export declare function isBooleanLiteral(node: Node, type: boolean, message?: string | Error): asserts node is typeof type extends true ? TrueLiteral : FalseLiteral;
 export declare function isTokenWithExpectedKind(maybe: Node, expected_kind: ts.SyntaxKind, message?: string | Error): asserts maybe is TypeNode & {
     kind: typeof expected_kind;
 };
+export declare function isExpectedIdentifier<T = string>(maybe: Node, expected: T, message?: string | Error): asserts maybe is Identifier & {
+    escapedText: T;
+};
+export declare function isUndefined(maybe: Node): asserts maybe is Identifier & {
+    escapedText: 'undefined';
+};
 declare const _default: {
     isBooleanLiteral: typeof isBooleanLiteral;
     isTokenWithExpectedKind: typeof isTokenWithExpectedKind;
+    isExpectedIdentifier: typeof isExpectedIdentifier;
+    isUndefined: typeof isUndefined;
     isAccessor: typeof import("../generated/assertions").isAccessor;
     isArrayBindingElement: typeof import("../generated/assertions").isArrayBindingElement;
     isArrayBindingPattern: typeof import("../generated/assertions").isArrayBindingPattern;
@@ -85,7 +93,7 @@ declare const _default: {
     isGetAccessor: typeof import("../generated/assertions").isGetAccessor;
     isGetAccessorDeclaration: typeof import("../generated/assertions").isGetAccessorDeclaration;
     isHeritageClause: typeof import("../generated/assertions").isHeritageClause;
-    isIdentifier: typeof import("../generated/assertions").isIdentifier;
+    isIdentifier: typeof isIdentifier;
     isIfStatement: typeof import("../generated/assertions").isIfStatement;
     isImportAttribute: typeof import("../generated/assertions").isImportAttribute;
     isImportAttributeName: typeof import("../generated/assertions").isImportAttributeName;

package/lib/main.js

@@ -1,4 +1,4 @@
-import generated, { isExpression, } from '../generated/assertions';
+import generated, { isExpression, isIdentifier, } from '../generated/assertions';
 import assert from 'node:assert/strict';
 import ts from 'typescript';
 export function isBooleanLiteral(node, type, message) {
@@ -10,9 +10,18 @@ export function isTokenWithExpectedKind(maybe, expected_kind, message) {
     assert.equal(ts.isTokenKind(maybe.kind), true, message);
     assert.equal(maybe.kind, expected_kind, message);
 }
+export function isExpectedIdentifier(maybe, expected, message) {
+    isIdentifier(maybe, message);
+    assert.equal(maybe.escapedText, expected, message);
+}
+export function isUndefined(maybe) {
+    isExpectedIdentifier(maybe, 'undefined');
+}
 export default {
     ...generated,
     isBooleanLiteral,
     isTokenWithExpectedKind,
+    isExpectedIdentifier,
+    isUndefined,
 };
 //# sourceMappingURL=main.js.map

package/package.json

@@ -27,5 +27,5 @@
     "dependencies": {
         "typescript": "^5.4.5"
     },
-    "version": "0.1.2"
+    "version": "0.2.0"
 }