@workday/canvas-kit-docs/dist/es6/docgen/traversals.js

Documentation components of Canvas Kit components

// This file is auto-generated from the createTraversals.ts file. Do not modify contents
import ts from 'typescript';
export const guards = {
    isNumericLiteral(node) {
        return node.kind === ts.SyntaxKind.NumericLiteral;
    },
    isBigIntLiteral(node) {
        return node.kind === ts.SyntaxKind.BigIntLiteral;
    },
    isStringLiteral(node) {
        return node.kind === ts.SyntaxKind.StringLiteral;
    },
    isJsxText(node) {
        return node.kind === ts.SyntaxKind.JsxText;
    },
    isRegularExpressionLiteral(node) {
        return node.kind === ts.SyntaxKind.RegularExpressionLiteral;
    },
    isNoSubstitutionTemplateLiteral(node) {
        return node.kind === ts.SyntaxKind.NoSubstitutionTemplateLiteral;
    },
    isTemplateHead(node) {
        return node.kind === ts.SyntaxKind.TemplateHead;
    },
    isTemplateMiddle(node) {
        return node.kind === ts.SyntaxKind.TemplateMiddle;
    },
    isTemplateTail(node) {
        return node.kind === ts.SyntaxKind.TemplateTail;
    },
    isIdentifier(node) {
        return node.kind === ts.SyntaxKind.Identifier;
    },
    isPrivateIdentifier(node) {
        return node.kind === ts.SyntaxKind.PrivateIdentifier;
    },
    isFalseKeyword(node) {
        return node.kind === ts.SyntaxKind.FalseKeyword;
    },
    isImportKeyword(node) {
        return node.kind === ts.SyntaxKind.ImportKeyword;
    },
    isNullKeyword(node) {
        return node.kind === ts.SyntaxKind.NullKeyword;
    },
    isSuperKeyword(node) {
        return node.kind === ts.SyntaxKind.SuperKeyword;
    },
    isThisKeyword(node) {
        return node.kind === ts.SyntaxKind.ThisKeyword;
    },
    isTrueKeyword(node) {
        return node.kind === ts.SyntaxKind.TrueKeyword;
    },
    isQualifiedName(node) {
        return node.kind === ts.SyntaxKind.QualifiedName;
    },
    isComputedPropertyName(node) {
        return node.kind === ts.SyntaxKind.ComputedPropertyName;
    },
    isTypeParameter(node) {
        return node.kind === ts.SyntaxKind.TypeParameter;
    },
    isParameter(node) {
        return node.kind === ts.SyntaxKind.Parameter;
    },
    isDecorator(node) {
        return node.kind === ts.SyntaxKind.Decorator;
    },
    isPropertySignature(node) {
        return node.kind === ts.SyntaxKind.PropertySignature;
    },
    isPropertyDeclaration(node) {
        return node.kind === ts.SyntaxKind.PropertyDeclaration;
    },
    isMethodSignature(node) {
        return node.kind === ts.SyntaxKind.MethodSignature;
    },
    isMethodDeclaration(node) {
        return node.kind === ts.SyntaxKind.MethodDeclaration;
    },
    isConstructor(node) {
        return node.kind === ts.SyntaxKind.Constructor;
    },
    isGetAccessor(node) {
        return node.kind === ts.SyntaxKind.GetAccessor;
    },
    isSetAccessor(node) {
        return node.kind === ts.SyntaxKind.SetAccessor;
    },
    isCallSignature(node) {
        return node.kind === ts.SyntaxKind.CallSignature;
    },
    isConstructSignature(node) {
        return node.kind === ts.SyntaxKind.ConstructSignature;
    },
    isIndexSignature(node) {
        return node.kind === ts.SyntaxKind.IndexSignature;
    },
    isTypePredicate(node) {
        return node.kind === ts.SyntaxKind.TypePredicate;
    },
    isTypeReference(node) {
        return node.kind === ts.SyntaxKind.TypeReference;
    },
    isFunctionType(node) {
        return node.kind === ts.SyntaxKind.FunctionType;
    },
    isConstructorType(node) {
        return node.kind === ts.SyntaxKind.ConstructorType;
    },
    isTypeQuery(node) {
        return node.kind === ts.SyntaxKind.TypeQuery;
    },
    isTypeLiteral(node) {
        return node.kind === ts.SyntaxKind.TypeLiteral;
    },
    isArrayType(node) {
        return node.kind === ts.SyntaxKind.ArrayType;
    },
    isTupleType(node) {
        return node.kind === ts.SyntaxKind.TupleType;
    },
    isOptionalType(node) {
        return node.kind === ts.SyntaxKind.OptionalType;
    },
    isRestType(node) {
        return node.kind === ts.SyntaxKind.RestType;
    },
    isUnionType(node) {
        return node.kind === ts.SyntaxKind.UnionType;
    },
    isIntersectionType(node) {
        return node.kind === ts.SyntaxKind.IntersectionType;
    },
    isConditionalType(node) {
        return node.kind === ts.SyntaxKind.ConditionalType;
    },
    isInferType(node) {
        return node.kind === ts.SyntaxKind.InferType;
    },
    isParenthesizedType(node) {
        return node.kind === ts.SyntaxKind.ParenthesizedType;
    },
    isThisType(node) {
        return node.kind === ts.SyntaxKind.ThisType;
    },
    isTypeOperator(node) {
        return node.kind === ts.SyntaxKind.TypeOperator;
    },
    isIndexedAccessType(node) {
        return node.kind === ts.SyntaxKind.IndexedAccessType;
    },
    isMappedType(node) {
        return node.kind === ts.SyntaxKind.MappedType;
    },
    isLiteralType(node) {
        return node.kind === ts.SyntaxKind.LiteralType;
    },
    isNamedTupleMember(node) {
        return node.kind === ts.SyntaxKind.NamedTupleMember;
    },
    isTemplateLiteralType(node) {
        return node.kind === ts.SyntaxKind.TemplateLiteralType;
    },
    isTemplateLiteralTypeSpan(node) {
        return node.kind === ts.SyntaxKind.TemplateLiteralTypeSpan;
    },
    isImportType(node) {
        return node.kind === ts.SyntaxKind.ImportType;
    },
    isObjectBindingPattern(node) {
        return node.kind === ts.SyntaxKind.ObjectBindingPattern;
    },
    isArrayBindingPattern(node) {
        return node.kind === ts.SyntaxKind.ArrayBindingPattern;
    },
    isBindingElement(node) {
        return node.kind === ts.SyntaxKind.BindingElement;
    },
    isArrayLiteralExpression(node) {
        return node.kind === ts.SyntaxKind.ArrayLiteralExpression;
    },
    isObjectLiteralExpression(node) {
        return node.kind === ts.SyntaxKind.ObjectLiteralExpression;
    },
    isPropertyAccessExpression(node) {
        return node.kind === ts.SyntaxKind.PropertyAccessExpression;
    },
    isElementAccessExpression(node) {
        return node.kind === ts.SyntaxKind.ElementAccessExpression;
    },
    isCallExpression(node) {
        return node.kind === ts.SyntaxKind.CallExpression;
    },
    isNewExpression(node) {
        return node.kind === ts.SyntaxKind.NewExpression;
    },
    isTaggedTemplateExpression(node) {
        return node.kind === ts.SyntaxKind.TaggedTemplateExpression;
    },
    isTypeAssertionExpression(node) {
        return node.kind === ts.SyntaxKind.TypeAssertionExpression;
    },
    isParenthesizedExpression(node) {
        return node.kind === ts.SyntaxKind.ParenthesizedExpression;
    },
    isFunctionExpression(node) {
        return node.kind === ts.SyntaxKind.FunctionExpression;
    },
    isArrowFunction(node) {
        return node.kind === ts.SyntaxKind.ArrowFunction;
    },
    isDeleteExpression(node) {
        return node.kind === ts.SyntaxKind.DeleteExpression;
    },
    isTypeOfExpression(node) {
        return node.kind === ts.SyntaxKind.TypeOfExpression;
    },
    isVoidExpression(node) {
        return node.kind === ts.SyntaxKind.VoidExpression;
    },
    isAwaitExpression(node) {
        return node.kind === ts.SyntaxKind.AwaitExpression;
    },
    isPrefixUnaryExpression(node) {
        return node.kind === ts.SyntaxKind.PrefixUnaryExpression;
    },
    isPostfixUnaryExpression(node) {
        return node.kind === ts.SyntaxKind.PostfixUnaryExpression;
    },
    isBinaryExpression(node) {
        return node.kind === ts.SyntaxKind.BinaryExpression;
    },
    isConditionalExpression(node) {
        return node.kind === ts.SyntaxKind.ConditionalExpression;
    },
    isTemplateExpression(node) {
        return node.kind === ts.SyntaxKind.TemplateExpression;
    },
    isYieldExpression(node) {
        return node.kind === ts.SyntaxKind.YieldExpression;
    },
    isSpreadElement(node) {
        return node.kind === ts.SyntaxKind.SpreadElement;
    },
    isClassExpression(node) {
        return node.kind === ts.SyntaxKind.ClassExpression;
    },
    isOmittedExpression(node) {
        return node.kind === ts.SyntaxKind.OmittedExpression;
    },
    isExpressionWithTypeArguments(node) {
        return node.kind === ts.SyntaxKind.ExpressionWithTypeArguments;
    },
    isAsExpression(node) {
        return node.kind === ts.SyntaxKind.AsExpression;
    },
    isNonNullExpression(node) {
        return node.kind === ts.SyntaxKind.NonNullExpression;
    },
    isMetaProperty(node) {
        return node.kind === ts.SyntaxKind.MetaProperty;
    },
    isSyntheticExpression(node) {
        return node.kind === ts.SyntaxKind.SyntheticExpression;
    },
    isTemplateSpan(node) {
        return node.kind === ts.SyntaxKind.TemplateSpan;
    },
    isSemicolonClassElement(node) {
        return node.kind === ts.SyntaxKind.SemicolonClassElement;
    },
    isBlock(node) {
        return node.kind === ts.SyntaxKind.Block;
    },
    isEmptyStatement(node) {
        return node.kind === ts.SyntaxKind.EmptyStatement;
    },
    isVariableStatement(node) {
        return node.kind === ts.SyntaxKind.VariableStatement;
    },
    isExpressionStatement(node) {
        return node.kind === ts.SyntaxKind.ExpressionStatement;
    },
    isIfStatement(node) {
        return node.kind === ts.SyntaxKind.IfStatement;
    },
    isDoStatement(node) {
        return node.kind === ts.SyntaxKind.DoStatement;
    },
    isWhileStatement(node) {
        return node.kind === ts.SyntaxKind.WhileStatement;
    },
    isForStatement(node) {
        return node.kind === ts.SyntaxKind.ForStatement;
    },
    isForInStatement(node) {
        return node.kind === ts.SyntaxKind.ForInStatement;
    },
    isForOfStatement(node) {
        return node.kind === ts.SyntaxKind.ForOfStatement;
    },
    isContinueStatement(node) {
        return node.kind === ts.SyntaxKind.ContinueStatement;
    },
    isBreakStatement(node) {
        return node.kind === ts.SyntaxKind.BreakStatement;
    },
    isReturnStatement(node) {
        return node.kind === ts.SyntaxKind.ReturnStatement;
    },
    isWithStatement(node) {
        return node.kind === ts.SyntaxKind.WithStatement;
    },
    isSwitchStatement(node) {
        return node.kind === ts.SyntaxKind.SwitchStatement;
    },
    isLabeledStatement(node) {
        return node.kind === ts.SyntaxKind.LabeledStatement;
    },
    isThrowStatement(node) {
        return node.kind === ts.SyntaxKind.ThrowStatement;
    },
    isTryStatement(node) {
        return node.kind === ts.SyntaxKind.TryStatement;
    },
    isDebuggerStatement(node) {
        return node.kind === ts.SyntaxKind.DebuggerStatement;
    },
    isVariableDeclaration(node) {
        return node.kind === ts.SyntaxKind.VariableDeclaration;
    },
    isVariableDeclarationList(node) {
        return node.kind === ts.SyntaxKind.VariableDeclarationList;
    },
    isFunctionDeclaration(node) {
        return node.kind === ts.SyntaxKind.FunctionDeclaration;
    },
    isClassDeclaration(node) {
        return node.kind === ts.SyntaxKind.ClassDeclaration;
    },
    isInterfaceDeclaration(node) {
        return node.kind === ts.SyntaxKind.InterfaceDeclaration;
    },
    isTypeAliasDeclaration(node) {
        return node.kind === ts.SyntaxKind.TypeAliasDeclaration;
    },
    isEnumDeclaration(node) {
        return node.kind === ts.SyntaxKind.EnumDeclaration;
    },
    isModuleDeclaration(node) {
        return node.kind === ts.SyntaxKind.ModuleDeclaration;
    },
    isModuleBlock(node) {
        return node.kind === ts.SyntaxKind.ModuleBlock;
    },
    isCaseBlock(node) {
        return node.kind === ts.SyntaxKind.CaseBlock;
    },
    isNamespaceExportDeclaration(node) {
        return node.kind === ts.SyntaxKind.NamespaceExportDeclaration;
    },
    isImportEqualsDeclaration(node) {
        return node.kind === ts.SyntaxKind.ImportEqualsDeclaration;
    },
    isImportDeclaration(node) {
        return node.kind === ts.SyntaxKind.ImportDeclaration;
    },
    isImportClause(node) {
        return node.kind === ts.SyntaxKind.ImportClause;
    },
    isNamespaceImport(node) {
        return node.kind === ts.SyntaxKind.NamespaceImport;
    },
    isNamedImports(node) {
        return node.kind === ts.SyntaxKind.NamedImports;
    },
    isImportSpecifier(node) {
        return node.kind === ts.SyntaxKind.ImportSpecifier;
    },
    isExportAssignment(node) {
        return node.kind === ts.SyntaxKind.ExportAssignment;
    },
    isExportDeclaration(node) {
        return node.kind === ts.SyntaxKind.ExportDeclaration;
    },
    isNamedExports(node) {
        return node.kind === ts.SyntaxKind.NamedExports;
    },
    isNamespaceExport(node) {
        return node.kind === ts.SyntaxKind.NamespaceExport;
    },
    isExportSpecifier(node) {
        return node.kind === ts.SyntaxKind.ExportSpecifier;
    },
    isMissingDeclaration(node) {
        return node.kind === ts.SyntaxKind.MissingDeclaration;
    },
    isExternalModuleReference(node) {
        return node.kind === ts.SyntaxKind.ExternalModuleReference;
    },
    isJsxElement(node) {
        return node.kind === ts.SyntaxKind.JsxElement;
    },
    isJsxSelfClosingElement(node) {
        return node.kind === ts.SyntaxKind.JsxSelfClosingElement;
    },
    isJsxOpeningElement(node) {
        return node.kind === ts.SyntaxKind.JsxOpeningElement;
    },
    isJsxClosingElement(node) {
        return node.kind === ts.SyntaxKind.JsxClosingElement;
    },
    isJsxFragment(node) {
        return node.kind === ts.SyntaxKind.JsxFragment;
    },
    isJsxOpeningFragment(node) {
        return node.kind === ts.SyntaxKind.JsxOpeningFragment;
    },
    isJsxClosingFragment(node) {
        return node.kind === ts.SyntaxKind.JsxClosingFragment;
    },
    isJsxAttribute(node) {
        return node.kind === ts.SyntaxKind.JsxAttribute;
    },
    isJsxAttributes(node) {
        return node.kind === ts.SyntaxKind.JsxAttributes;
    },
    isJsxSpreadAttribute(node) {
        return node.kind === ts.SyntaxKind.JsxSpreadAttribute;
    },
    isJsxExpression(node) {
        return node.kind === ts.SyntaxKind.JsxExpression;
    },
    isCaseClause(node) {
        return node.kind === ts.SyntaxKind.CaseClause;
    },
    isDefaultClause(node) {
        return node.kind === ts.SyntaxKind.DefaultClause;
    },
    isHeritageClause(node) {
        return node.kind === ts.SyntaxKind.HeritageClause;
    },
    isCatchClause(node) {
        return node.kind === ts.SyntaxKind.CatchClause;
    },
    isPropertyAssignment(node) {
        return node.kind === ts.SyntaxKind.PropertyAssignment;
    },
    isShorthandPropertyAssignment(node) {
        return node.kind === ts.SyntaxKind.ShorthandPropertyAssignment;
    },
    isSpreadAssignment(node) {
        return node.kind === ts.SyntaxKind.SpreadAssignment;
    },
    isEnumMember(node) {
        return node.kind === ts.SyntaxKind.EnumMember;
    },
    isUnparsedPrologue(node) {
        return node.kind === ts.SyntaxKind.UnparsedPrologue;
    },
    isUnparsedPrepend(node) {
        return node.kind === ts.SyntaxKind.UnparsedPrepend;
    },
    isUnparsedSyntheticReference(node) {
        return node.kind === ts.SyntaxKind.UnparsedSyntheticReference;
    },
    isSourceFile(node) {
        return node.kind === ts.SyntaxKind.SourceFile;
    },
    isBundle(node) {
        return node.kind === ts.SyntaxKind.Bundle;
    },
    isUnparsedSource(node) {
        return node.kind === ts.SyntaxKind.UnparsedSource;
    },
    isInputFiles(node) {
        return node.kind === ts.SyntaxKind.InputFiles;
    },
    isJSDocTypeExpression(node) {
        return node.kind === ts.SyntaxKind.JSDocTypeExpression;
    },
    isJSDocNameReference(node) {
        return node.kind === ts.SyntaxKind.JSDocNameReference;
    },
    isJSDocAllType(node) {
        return node.kind === ts.SyntaxKind.JSDocAllType;
    },
    isJSDocUnknownType(node) {
        return node.kind === ts.SyntaxKind.JSDocUnknownType;
    },
    isJSDocNullableType(node) {
        return node.kind === ts.SyntaxKind.JSDocNullableType;
    },
    isJSDocNonNullableType(node) {
        return node.kind === ts.SyntaxKind.JSDocNonNullableType;
    },
    isJSDocOptionalType(node) {
        return node.kind === ts.SyntaxKind.JSDocOptionalType;
    },
    isJSDocFunctionType(node) {
        return node.kind === ts.SyntaxKind.JSDocFunctionType;
    },
    isJSDocVariadicType(node) {
        return node.kind === ts.SyntaxKind.JSDocVariadicType;
    },
    isJSDocNamepathType(node) {
        return node.kind === ts.SyntaxKind.JSDocNamepathType;
    },
    isJSDocComment(node) {
        return node.kind === ts.SyntaxKind.JSDocComment;
    },
    isJSDocTypeLiteral(node) {
        return node.kind === ts.SyntaxKind.JSDocTypeLiteral;
    },
    isJSDocSignature(node) {
        return node.kind === ts.SyntaxKind.JSDocSignature;
    },
    isJSDocTag(node) {
        return node.kind === ts.SyntaxKind.JSDocTag;
    },
    isJSDocAugmentsTag(node) {
        return node.kind === ts.SyntaxKind.JSDocAugmentsTag;
    },
    isJSDocImplementsTag(node) {
        return node.kind === ts.SyntaxKind.JSDocImplementsTag;
    },
    isJSDocAuthorTag(node) {
        return node.kind === ts.SyntaxKind.JSDocAuthorTag;
    },
    isJSDocDeprecatedTag(node) {
        return node.kind === ts.SyntaxKind.JSDocDeprecatedTag;
    },
    isJSDocClassTag(node) {
        return node.kind === ts.SyntaxKind.JSDocClassTag;
    },
    isJSDocPublicTag(node) {
        return node.kind === ts.SyntaxKind.JSDocPublicTag;
    },
    isJSDocPrivateTag(node) {
        return node.kind === ts.SyntaxKind.JSDocPrivateTag;
    },
    isJSDocProtectedTag(node) {
        return node.kind === ts.SyntaxKind.JSDocProtectedTag;
    },
    isJSDocReadonlyTag(node) {
        return node.kind === ts.SyntaxKind.JSDocReadonlyTag;
    },
    isJSDocCallbackTag(node) {
        return node.kind === ts.SyntaxKind.JSDocCallbackTag;
    },
    isJSDocEnumTag(node) {
        return node.kind === ts.SyntaxKind.JSDocEnumTag;
    },
    isJSDocParameterTag(node) {
        return node.kind === ts.SyntaxKind.JSDocParameterTag;
    },
    isJSDocReturnTag(node) {
        return node.kind === ts.SyntaxKind.JSDocReturnTag;
    },
    isJSDocThisTag(node) {
        return node.kind === ts.SyntaxKind.JSDocThisTag;
    },
    isJSDocTypeTag(node) {
        return node.kind === ts.SyntaxKind.JSDocTypeTag;
    },
    isJSDocTemplateTag(node) {
        return node.kind === ts.SyntaxKind.JSDocTemplateTag;
    },
    isJSDocTypedefTag(node) {
        return node.kind === ts.SyntaxKind.JSDocTypedefTag;
    },
    isJSDocSeeTag(node) {
        return node.kind === ts.SyntaxKind.JSDocSeeTag;
    },
    isJSDocPropertyTag(node) {
        return node.kind === ts.SyntaxKind.JSDocPropertyTag;
    },
    isSyntaxList(node) {
        return node.kind === ts.SyntaxKind.SyntaxList;
    },
    isNotEmittedStatement(node) {
        return node.kind === ts.SyntaxKind.NotEmittedStatement;
    },
    isPartiallyEmittedExpression(node) {
        return node.kind === ts.SyntaxKind.PartiallyEmittedExpression;
    },
    isCommaListExpression(node) {
        return node.kind === ts.SyntaxKind.CommaListExpression;
    },
};
export const kindsMap = {
    NumericLiteral: {},
    BigIntLiteral: {},
    StringLiteral: {},
    JsxText: {},
    RegularExpressionLiteral: {},
    NoSubstitutionTemplateLiteral: {},
    TemplateHead: {},
    TemplateMiddle: {},
    TemplateTail: {},
    Identifier: {},
    PrivateIdentifier: {},
    FalseKeyword: {},
    ImportKeyword: {},
    NullKeyword: {},
    SuperKeyword: {},
    ThisKeyword: {},
    TrueKeyword: {},
    QualifiedName: {},
    ComputedPropertyName: {},
    TypeParameter: {},
    Parameter: {},
    Decorator: {},
    PropertySignature: {},
    PropertyDeclaration: {},
    MethodSignature: {},
    MethodDeclaration: {},
    Constructor: {},
    GetAccessor: {},
    SetAccessor: {},
    CallSignature: {},
    ConstructSignature: {},
    IndexSignature: {},
    TypePredicate: {},
    TypeReference: {},
    FunctionType: {},
    ConstructorType: {},
    TypeQuery: {},
    TypeLiteral: {},
    ArrayType: {},
    TupleType: {},
    OptionalType: {},
    RestType: {},
    UnionType: {},
    IntersectionType: {},
    ConditionalType: {},
    InferType: {},
    ParenthesizedType: {},
    ThisType: {},
    TypeOperator: {},
    IndexedAccessType: {},
    MappedType: {},
    LiteralType: {},
    NamedTupleMember: {},
    TemplateLiteralType: {},
    TemplateLiteralTypeSpan: {},
    ImportType: {},
    ObjectBindingPattern: {},
    ArrayBindingPattern: {},
    BindingElement: {},
    ArrayLiteralExpression: {},
    ObjectLiteralExpression: {},
    PropertyAccessExpression: {},
    ElementAccessExpression: {},
    CallExpression: {},
    NewExpression: {},
    TaggedTemplateExpression: {},
    TypeAssertionExpression: {},
    ParenthesizedExpression: {},
    FunctionExpression: {},
    ArrowFunction: {},
    DeleteExpression: {},
    TypeOfExpression: {},
    VoidExpression: {},
    AwaitExpression: {},
    PrefixUnaryExpression: {},
    PostfixUnaryExpression: {},
    BinaryExpression: {},
    ConditionalExpression: {},
    TemplateExpression: {},
    YieldExpression: {},
    SpreadElement: {},
    ClassExpression: {},
    OmittedExpression: {},
    ExpressionWithTypeArguments: {},
    AsExpression: {},
    NonNullExpression: {},
    MetaProperty: {},
    SyntheticExpression: {},
    TemplateSpan: {},
    SemicolonClassElement: {},
    Block: {},
    EmptyStatement: {},
    VariableStatement: {},
    ExpressionStatement: {},
    IfStatement: {},
    DoStatement: {},
    WhileStatement: {},
    ForStatement: {},
    ForInStatement: {},
    ForOfStatement: {},
    ContinueStatement: {},
    BreakStatement: {},
    ReturnStatement: {},
    WithStatement: {},
    SwitchStatement: {},
    LabeledStatement: {},
    ThrowStatement: {},
    TryStatement: {},
    DebuggerStatement: {},
    VariableDeclaration: {},
    VariableDeclarationList: {},
    FunctionDeclaration: {},
    ClassDeclaration: {},
    InterfaceDeclaration: {},
    TypeAliasDeclaration: {},
    EnumDeclaration: {},
    ModuleDeclaration: {},
    ModuleBlock: {},
    CaseBlock: {},
    NamespaceExportDeclaration: {},
    ImportEqualsDeclaration: {},
    ImportDeclaration: {},
    ImportClause: {},
    NamespaceImport: {},
    NamedImports: {},
    ImportSpecifier: {},
    ExportAssignment: {},
    ExportDeclaration: {},
    NamedExports: {},
    NamespaceExport: {},
    ExportSpecifier: {},
    MissingDeclaration: {},
    ExternalModuleReference: {},
    JsxElement: {},
    JsxSelfClosingElement: {},
    JsxOpeningElement: {},
    JsxClosingElement: {},
    JsxFragment: {},
    JsxOpeningFragment: {},
    JsxClosingFragment: {},
    JsxAttribute: {},
    JsxAttributes: {},
    JsxSpreadAttribute: {},
    JsxExpression: {},
    CaseClause: {},
    DefaultClause: {},
    HeritageClause: {},
    CatchClause: {},
    PropertyAssignment: {},
    ShorthandPropertyAssignment: {},
    SpreadAssignment: {},
    EnumMember: {},
    UnparsedPrologue: {},
    UnparsedPrepend: {},
    UnparsedSyntheticReference: {},
    SourceFile: {},
    Bundle: {},
    UnparsedSource: {},
    InputFiles: {},
    JSDocTypeExpression: {},
    JSDocNameReference: {},
    JSDocAllType: {},
    JSDocUnknownType: {},
    JSDocNullableType: {},
    JSDocNonNullableType: {},
    JSDocOptionalType: {},
    JSDocFunctionType: {},
    JSDocVariadicType: {},
    JSDocNamepathType: {},
    JSDocComment: {},
    JSDocTypeLiteral: {},
    JSDocSignature: {},
    JSDocTag: {},
    JSDocAugmentsTag: {},
    JSDocImplementsTag: {},
    JSDocAuthorTag: {},
    JSDocDeprecatedTag: {},
    JSDocClassTag: {},
    JSDocPublicTag: {},
    JSDocPrivateTag: {},
    JSDocProtectedTag: {},
    JSDocReadonlyTag: {},
    JSDocCallbackTag: {},
    JSDocEnumTag: {},
    JSDocParameterTag: {},
    JSDocReturnTag: {},
    JSDocThisTag: {},
    JSDocTypeTag: {},
    JSDocTemplateTag: {},
    JSDocTypedefTag: {},
    JSDocSeeTag: {},
    JSDocPropertyTag: {},
    SyntaxList: {},
    NotEmittedStatement: {},
    PartiallyEmittedExpression: {},
    CommaListExpression: {},
};
const kindToString = {
    [ts.SyntaxKind.NumericLiteral]: 'NumericLiteral',
    [ts.SyntaxKind.BigIntLiteral]: 'BigIntLiteral',
    [ts.SyntaxKind.StringLiteral]: 'StringLiteral',
    [ts.SyntaxKind.JsxText]: 'JsxText',
    [ts.SyntaxKind.RegularExpressionLiteral]: 'RegularExpressionLiteral',
    [ts.SyntaxKind.NoSubstitutionTemplateLiteral]: 'NoSubstitutionTemplateLiteral',
    [ts.SyntaxKind.TemplateHead]: 'TemplateHead',
    [ts.SyntaxKind.TemplateMiddle]: 'TemplateMiddle',
    [ts.SyntaxKind.TemplateTail]: 'TemplateTail',
    [ts.SyntaxKind.Identifier]: 'Identifier',
    [ts.SyntaxKind.PrivateIdentifier]: 'PrivateIdentifier',
    [ts.SyntaxKind.FalseKeyword]: 'FalseKeyword',
    [ts.SyntaxKind.ImportKeyword]: 'ImportKeyword',
    [ts.SyntaxKind.NullKeyword]: 'NullKeyword',
    [ts.SyntaxKind.SuperKeyword]: 'SuperKeyword',
    [ts.SyntaxKind.ThisKeyword]: 'ThisKeyword',
    [ts.SyntaxKind.TrueKeyword]: 'TrueKeyword',
    [ts.SyntaxKind.QualifiedName]: 'QualifiedName',
    [ts.SyntaxKind.ComputedPropertyName]: 'ComputedPropertyName',
    [ts.SyntaxKind.TypeParameter]: 'TypeParameter',
    [ts.SyntaxKind.Parameter]: 'Parameter',
    [ts.SyntaxKind.Decorator]: 'Decorator',
    [ts.SyntaxKind.PropertySignature]: 'PropertySignature',
    [ts.SyntaxKind.PropertyDeclaration]: 'PropertyDeclaration',
    [ts.SyntaxKind.MethodSignature]: 'MethodSignature',
    [ts.SyntaxKind.MethodDeclaration]: 'MethodDeclaration',
    [ts.SyntaxKind.Constructor]: 'Constructor',
    [ts.SyntaxKind.GetAccessor]: 'GetAccessor',
    [ts.SyntaxKind.SetAccessor]: 'SetAccessor',
    [ts.SyntaxKind.CallSignature]: 'CallSignature',
    [ts.SyntaxKind.ConstructSignature]: 'ConstructSignature',
    [ts.SyntaxKind.IndexSignature]: 'IndexSignature',
    [ts.SyntaxKind.TypePredicate]: 'TypePredicate',
    [ts.SyntaxKind.TypeReference]: 'TypeReference',
    [ts.SyntaxKind.FunctionType]: 'FunctionType',
    [ts.SyntaxKind.ConstructorType]: 'ConstructorType',
    [ts.SyntaxKind.TypeQuery]: 'TypeQuery',
    [ts.SyntaxKind.TypeLiteral]: 'TypeLiteral',
    [ts.SyntaxKind.ArrayType]: 'ArrayType',
    [ts.SyntaxKind.TupleType]: 'TupleType',
    [ts.SyntaxKind.OptionalType]: 'OptionalType',
    [ts.SyntaxKind.RestType]: 'RestType',
    [ts.SyntaxKind.UnionType]: 'UnionType',
    [ts.SyntaxKind.IntersectionType]: 'IntersectionType',
    [ts.SyntaxKind.ConditionalType]: 'ConditionalType',
    [ts.SyntaxKind.InferType]: 'InferType',
    [ts.SyntaxKind.ParenthesizedType]: 'ParenthesizedType',
    [ts.SyntaxKind.ThisType]: 'ThisType',
    [ts.SyntaxKind.TypeOperator]: 'TypeOperator',
    [ts.SyntaxKind.IndexedAccessType]: 'IndexedAccessType',
    [ts.SyntaxKind.MappedType]: 'MappedType',
    [ts.SyntaxKind.LiteralType]: 'LiteralType',
    [ts.SyntaxKind.NamedTupleMember]: 'NamedTupleMember',
    [ts.SyntaxKind.TemplateLiteralType]: 'TemplateLiteralType',
    [ts.SyntaxKind.TemplateLiteralTypeSpan]: 'TemplateLiteralTypeSpan',
    [ts.SyntaxKind.ImportType]: 'ImportType',
    [ts.SyntaxKind.ObjectBindingPattern]: 'ObjectBindingPattern',
    [ts.SyntaxKind.ArrayBindingPattern]: 'ArrayBindingPattern',
    [ts.SyntaxKind.BindingElement]: 'BindingElement',
    [ts.SyntaxKind.ArrayLiteralExpression]: 'ArrayLiteralExpression',
    [ts.SyntaxKind.ObjectLiteralExpression]: 'ObjectLiteralExpression',
    [ts.SyntaxKind.PropertyAccessExpression]: 'PropertyAccessExpression',
    [ts.SyntaxKind.ElementAccessExpression]: 'ElementAccessExpression',
    [ts.SyntaxKind.CallExpression]: 'CallExpression',
    [ts.SyntaxKind.NewExpression]: 'NewExpression',
    [ts.SyntaxKind.TaggedTemplateExpression]: 'TaggedTemplateExpression',
    [ts.SyntaxKind.TypeAssertionExpression]: 'TypeAssertionExpression',
    [ts.SyntaxKind.ParenthesizedExpression]: 'ParenthesizedExpression',
    [ts.SyntaxKind.FunctionExpression]: 'FunctionExpression',
    [ts.SyntaxKind.ArrowFunction]: 'ArrowFunction',
    [ts.SyntaxKind.DeleteExpression]: 'DeleteExpression',
    [ts.SyntaxKind.TypeOfExpression]: 'TypeOfExpression',
    [ts.SyntaxKind.VoidExpression]: 'VoidExpression',
    [ts.SyntaxKind.AwaitExpression]: 'AwaitExpression',
    [ts.SyntaxKind.PrefixUnaryExpression]: 'PrefixUnaryExpression',
    [ts.SyntaxKind.PostfixUnaryExpression]: 'PostfixUnaryExpression',
    [ts.SyntaxKind.BinaryExpression]: 'BinaryExpression',
    [ts.SyntaxKind.ConditionalExpression]: 'ConditionalExpression',
    [ts.SyntaxKind.TemplateExpression]: 'TemplateExpression',
    [ts.SyntaxKind.YieldExpression]: 'YieldExpression',
    [ts.SyntaxKind.SpreadElement]: 'SpreadElement',
    [ts.SyntaxKind.ClassExpression]: 'ClassExpression',
    [ts.SyntaxKind.OmittedExpression]: 'OmittedExpression',
    [ts.SyntaxKind.ExpressionWithTypeArguments]: 'ExpressionWithTypeArguments',
    [ts.SyntaxKind.AsExpression]: 'AsExpression',
    [ts.SyntaxKind.NonNullExpression]: 'NonNullExpression',
    [ts.SyntaxKind.MetaProperty]: 'MetaProperty',
    [ts.SyntaxKind.SyntheticExpression]: 'SyntheticExpression',
    [ts.SyntaxKind.TemplateSpan]: 'TemplateSpan',
    [ts.SyntaxKind.SemicolonClassElement]: 'SemicolonClassElement',
    [ts.SyntaxKind.Block]: 'Block',
    [ts.SyntaxKind.EmptyStatement]: 'EmptyStatement',
    [ts.SyntaxKind.VariableStatement]: 'VariableStatement',
    [ts.SyntaxKind.ExpressionStatement]: 'ExpressionStatement',
    [ts.SyntaxKind.IfStatement]: 'IfStatement',
    [ts.SyntaxKind.DoStatement]: 'DoStatement',
    [ts.SyntaxKind.WhileStatement]: 'WhileStatement',
    [ts.SyntaxKind.ForStatement]: 'ForStatement',
    [ts.SyntaxKind.ForInStatement]: 'ForInStatement',
    [ts.SyntaxKind.ForOfStatement]: 'ForOfStatement',
    [ts.SyntaxKind.ContinueStatement]: 'ContinueStatement',
    [ts.SyntaxKind.BreakStatement]: 'BreakStatement',
    [ts.SyntaxKind.ReturnStatement]: 'ReturnStatement',
    [ts.SyntaxKind.WithStatement]: 'WithStatement',
    [ts.SyntaxKind.SwitchStatement]: 'SwitchStatement',
    [ts.SyntaxKind.LabeledStatement]: 'LabeledStatement',
    [ts.SyntaxKind.ThrowStatement]: 'ThrowStatement',
    [ts.SyntaxKind.TryStatement]: 'TryStatement',
    [ts.SyntaxKind.DebuggerStatement]: 'DebuggerStatement',
    [ts.SyntaxKind.VariableDeclaration]: 'VariableDeclaration',
    [ts.SyntaxKind.VariableDeclarationList]: 'VariableDeclarationList',
    [ts.SyntaxKind.FunctionDeclaration]: 'FunctionDeclaration',
    [ts.SyntaxKind.ClassDeclaration]: 'ClassDeclaration',
    [ts.SyntaxKind.InterfaceDeclaration]: 'InterfaceDeclaration',
    [ts.SyntaxKind.TypeAliasDeclaration]: 'TypeAliasDeclaration',
    [ts.SyntaxKind.EnumDeclaration]: 'EnumDeclaration',
    [ts.SyntaxKind.ModuleDeclaration]: 'ModuleDeclaration',
    [ts.SyntaxKind.ModuleBlock]: 'ModuleBlock',
    [ts.SyntaxKind.CaseBlock]: 'CaseBlock',
    [ts.SyntaxKind.NamespaceExportDeclaration]: 'NamespaceExportDeclaration',
    [ts.SyntaxKind.ImportEqualsDeclaration]: 'ImportEqualsDeclaration',
    [ts.SyntaxKind.ImportDeclaration]: 'ImportDeclaration',
    [ts.SyntaxKind.ImportClause]: 'ImportClause',
    [ts.SyntaxKind.NamespaceImport]: 'NamespaceImport',
    [ts.SyntaxKind.NamedImports]: 'NamedImports',
    [ts.SyntaxKind.ImportSpecifier]: 'ImportSpecifier',
    [ts.SyntaxKind.ExportAssignment]: 'ExportAssignment',
    [ts.SyntaxKind.ExportDeclaration]: 'ExportDeclaration',
    [ts.SyntaxKind.NamedExports]: 'NamedExports',
    [ts.SyntaxKind.NamespaceExport]: 'NamespaceExport',
    [ts.SyntaxKind.ExportSpecifier]: 'ExportSpecifier',
    [ts.SyntaxKind.MissingDeclaration]: 'MissingDeclaration',
    [ts.SyntaxKind.ExternalModuleReference]: 'ExternalModuleReference',
    [ts.SyntaxKind.JsxElement]: 'JsxElement',
    [ts.SyntaxKind.JsxSelfClosingElement]: 'JsxSelfClosingElement',
    [ts.SyntaxKind.JsxOpeningElement]: 'JsxOpeningElement',
    [ts.SyntaxKind.JsxClosingElement]: 'JsxClosingElement',
    [ts.SyntaxKind.JsxFragment]: 'JsxFragment',
    [ts.SyntaxKind.JsxOpeningFragment]: 'JsxOpeningFragment',
    [ts.SyntaxKind.JsxClosingFragment]: 'JsxClosingFragment',
    [ts.SyntaxKind.JsxAttribute]: 'JsxAttribute',
    [ts.SyntaxKind.JsxAttributes]: 'JsxAttributes',
    [ts.SyntaxKind.JsxSpreadAttribute]: 'JsxSpreadAttribute',
    [ts.SyntaxKind.JsxExpression]: 'JsxExpression',
    [ts.SyntaxKind.CaseClause]: 'CaseClause',
    [ts.SyntaxKind.DefaultClause]: 'DefaultClause',
    [ts.SyntaxKind.HeritageClause]: 'HeritageClause',
    [ts.SyntaxKind.CatchClause]: 'CatchClause',
    [ts.SyntaxKind.PropertyAssignment]: 'PropertyAssignment',
    [ts.SyntaxKind.ShorthandPropertyAssignment]: 'ShorthandPropertyAssignment',
    [ts.SyntaxKind.SpreadAssignment]: 'SpreadAssignment',
    [ts.SyntaxKind.EnumMember]: 'EnumMember',
    [ts.SyntaxKind.UnparsedPrologue]: 'UnparsedPrologue',
    [ts.SyntaxKind.UnparsedPrepend]: 'UnparsedPrepend',
    [ts.SyntaxKind.UnparsedSyntheticReference]: 'UnparsedSyntheticReference',
    [ts.SyntaxKind.SourceFile]: 'SourceFile',
    [ts.SyntaxKind.Bundle]: 'Bundle',
    [ts.SyntaxKind.UnparsedSource]: 'UnparsedSource',
    [ts.SyntaxKind.InputFiles]: 'InputFiles',
    [ts.SyntaxKind.JSDocTypeExpression]: 'JSDocTypeExpression',
    [ts.SyntaxKind.JSDocNameReference]: 'JSDocNameReference',
    [ts.SyntaxKind.JSDocAllType]: 'JSDocAllType',
    [ts.SyntaxKind.JSDocUnknownType]: 'JSDocUnknownType',
    [ts.SyntaxKind.JSDocNullableType]: 'JSDocNullableType',
    [ts.SyntaxKind.JSDocNonNullableType]: 'JSDocNonNullableType',
    [ts.SyntaxKind.JSDocOptionalType]: 'JSDocOptionalType',
    [ts.SyntaxKind.JSDocFunctionType]: 'JSDocFunctionType',
    [ts.SyntaxKind.JSDocVariadicType]: 'JSDocVariadicType',
    [ts.SyntaxKind.JSDocNamepathType]: 'JSDocNamepathType',
    [ts.SyntaxKind.JSDocComment]: 'JSDocComment',
    [ts.SyntaxKind.JSDocTypeLiteral]: 'JSDocTypeLiteral',
    [ts.SyntaxKind.JSDocSignature]: 'JSDocSignature',
    [ts.SyntaxKind.JSDocTag]: 'JSDocTag',
    [ts.SyntaxKind.JSDocAugmentsTag]: 'JSDocAugmentsTag',
    [ts.SyntaxKind.JSDocImplementsTag]: 'JSDocImplementsTag',
    [ts.SyntaxKind.JSDocAuthorTag]: 'JSDocAuthorTag',
    [ts.SyntaxKind.JSDocDeprecatedTag]: 'JSDocDeprecatedTag',
    [ts.SyntaxKind.JSDocClassTag]: 'JSDocClassTag',
    [ts.SyntaxKind.JSDocPublicTag]: 'JSDocPublicTag',
    [ts.SyntaxKind.JSDocPrivateTag]: 'JSDocPrivateTag',
    [ts.SyntaxKind.JSDocProtectedTag]: 'JSDocProtectedTag',
    [ts.SyntaxKind.JSDocReadonlyTag]: 'JSDocReadonlyTag',
    [ts.SyntaxKind.JSDocCallbackTag]: 'JSDocCallbackTag',
    [ts.SyntaxKind.JSDocEnumTag]: 'JSDocEnumTag',
    [ts.SyntaxKind.JSDocParameterTag]: 'JSDocParameterTag',
    [ts.SyntaxKind.JSDocReturnTag]: 'JSDocReturnTag',
    [ts.SyntaxKind.JSDocThisTag]: 'JSDocThisTag',
    [ts.SyntaxKind.JSDocTypeTag]: 'JSDocTypeTag',
    [ts.SyntaxKind.JSDocTemplateTag]: 'JSDocTemplateTag',
    [ts.SyntaxKind.JSDocTypedefTag]: 'JSDocTypedefTag',
    [ts.SyntaxKind.JSDocSeeTag]: 'JSDocSeeTag',
    [ts.SyntaxKind.JSDocPropertyTag]: 'JSDocPropertyTag',
    [ts.SyntaxKind.SyntaxList]: 'SyntaxList',
    [ts.SyntaxKind.NotEmittedStatement]: 'NotEmittedStatement',
    [ts.SyntaxKind.PartiallyEmittedExpression]: 'PartiallyEmittedExpression',
    [ts.SyntaxKind.CommaListExpression]: 'CommaListExpression',
};
export function getKindNameFromNode(node) {
    // @ts-ignore
    return kindToString[node.kind] || String(node.kind);
}