@putout/plugin-putout 23.4.1 → 23.6.0

package/lib/declare/types.json

@@ -170,6 +170,7 @@
     "TSConstructorType": "const {TSConstructorType} = types",
     "TSDeclareFunction": "const {TSDeclareFunction} = types",
     "TSDeclareMethod": "const {TSDeclareMethod} = types",
+    "TSEnumBody": "const {TSEnumBody} = types",
     "TSEnumDeclaration": "const {TSEnumDeclaration} = types",
     "TSEnumMember": "const {TSEnumMember} = types",
     "TSExportAssignment": "const {TSExportAssignment} = types",
@@ -207,6 +208,7 @@
     "TSSatisfiesExpression": "const {TSSatisfiesExpression} = types",
     "TSStringKeyword": "const {TSStringKeyword} = types",
     "TSSymbolKeyword": "const {TSSymbolKeyword} = types",
+    "TSTemplateLiteralType": "const {TSTemplateLiteralType} = types",
     "TSThisType": "const {TSThisType} = types",
     "TSTupleType": "const {TSTupleType} = types",
     "TSTypeAliasDeclaration": "const {TSTypeAliasDeclaration} = types",
@@ -252,6 +254,427 @@
     "WhileStatement": "const {WhileStatement} = types",
     "WithStatement": "const {WithStatement} = types",
     "YieldExpression": "const {YieldExpression} = types",
+    "addComment": "const {addComment} = types",
+    "addComments": "const {addComments} = types",
+    "anyTypeAnnotation": "const {anyTypeAnnotation} = types",
+    "appendToMemberExpression": "const {appendToMemberExpression} = types",
+    "argumentPlaceholder": "const {argumentPlaceholder} = types",
+    "arrayExpression": "const {arrayExpression} = types",
+    "arrayPattern": "const {arrayPattern} = types",
+    "arrayTypeAnnotation": "const {arrayTypeAnnotation} = types",
+    "arrowFunctionExpression": "const {arrowFunctionExpression} = types",
+    "assertAccessor": "const {assertAccessor} = types",
+    "assertAnyTypeAnnotation": "const {assertAnyTypeAnnotation} = types",
+    "assertArgumentPlaceholder": "const {assertArgumentPlaceholder} = types",
+    "assertArrayExpression": "const {assertArrayExpression} = types",
+    "assertArrayPattern": "const {assertArrayPattern} = types",
+    "assertArrayTypeAnnotation": "const {assertArrayTypeAnnotation} = types",
+    "assertArrowFunctionExpression": "const {assertArrowFunctionExpression} = types",
+    "assertAssignmentExpression": "const {assertAssignmentExpression} = types",
+    "assertAssignmentPattern": "const {assertAssignmentPattern} = types",
+    "assertAwaitExpression": "const {assertAwaitExpression} = types",
+    "assertBigIntLiteral": "const {assertBigIntLiteral} = types",
+    "assertBinary": "const {assertBinary} = types",
+    "assertBinaryExpression": "const {assertBinaryExpression} = types",
+    "assertBindExpression": "const {assertBindExpression} = types",
+    "assertBlock": "const {assertBlock} = types",
+    "assertBlockParent": "const {assertBlockParent} = types",
+    "assertBlockStatement": "const {assertBlockStatement} = types",
+    "assertBooleanLiteral": "const {assertBooleanLiteral} = types",
+    "assertBooleanLiteralTypeAnnotation": "const {assertBooleanLiteralTypeAnnotation} = types",
+    "assertBooleanTypeAnnotation": "const {assertBooleanTypeAnnotation} = types",
+    "assertBreakStatement": "const {assertBreakStatement} = types",
+    "assertCallExpression": "const {assertCallExpression} = types",
+    "assertCatchClause": "const {assertCatchClause} = types",
+    "assertClass": "const {assertClass} = types",
+    "assertClassAccessorProperty": "const {assertClassAccessorProperty} = types",
+    "assertClassBody": "const {assertClassBody} = types",
+    "assertClassDeclaration": "const {assertClassDeclaration} = types",
+    "assertClassExpression": "const {assertClassExpression} = types",
+    "assertClassImplements": "const {assertClassImplements} = types",
+    "assertClassMethod": "const {assertClassMethod} = types",
+    "assertClassPrivateMethod": "const {assertClassPrivateMethod} = types",
+    "assertClassPrivateProperty": "const {assertClassPrivateProperty} = types",
+    "assertClassProperty": "const {assertClassProperty} = types",
+    "assertCompletionStatement": "const {assertCompletionStatement} = types",
+    "assertConditional": "const {assertConditional} = types",
+    "assertConditionalExpression": "const {assertConditionalExpression} = types",
+    "assertContinueStatement": "const {assertContinueStatement} = types",
+    "assertDebuggerStatement": "const {assertDebuggerStatement} = types",
+    "assertDeclaration": "const {assertDeclaration} = types",
+    "assertDeclareClass": "const {assertDeclareClass} = types",
+    "assertDeclareExportAllDeclaration": "const {assertDeclareExportAllDeclaration} = types",
+    "assertDeclareExportDeclaration": "const {assertDeclareExportDeclaration} = types",
+    "assertDeclareFunction": "const {assertDeclareFunction} = types",
+    "assertDeclareInterface": "const {assertDeclareInterface} = types",
+    "assertDeclareModule": "const {assertDeclareModule} = types",
+    "assertDeclareModuleExports": "const {assertDeclareModuleExports} = types",
+    "assertDeclareOpaqueType": "const {assertDeclareOpaqueType} = types",
+    "assertDeclareTypeAlias": "const {assertDeclareTypeAlias} = types",
+    "assertDeclareVariable": "const {assertDeclareVariable} = types",
+    "assertDeclaredPredicate": "const {assertDeclaredPredicate} = types",
+    "assertDecorator": "const {assertDecorator} = types",
+    "assertDirective": "const {assertDirective} = types",
+    "assertDirectiveLiteral": "const {assertDirectiveLiteral} = types",
+    "assertDoExpression": "const {assertDoExpression} = types",
+    "assertDoWhileStatement": "const {assertDoWhileStatement} = types",
+    "assertEmptyStatement": "const {assertEmptyStatement} = types",
+    "assertEmptyTypeAnnotation": "const {assertEmptyTypeAnnotation} = types",
+    "assertEnumBody": "const {assertEnumBody} = types",
+    "assertEnumBooleanBody": "const {assertEnumBooleanBody} = types",
+    "assertEnumBooleanMember": "const {assertEnumBooleanMember} = types",
+    "assertEnumDeclaration": "const {assertEnumDeclaration} = types",
+    "assertEnumDefaultedMember": "const {assertEnumDefaultedMember} = types",
+    "assertEnumMember": "const {assertEnumMember} = types",
+    "assertEnumNumberBody": "const {assertEnumNumberBody} = types",
+    "assertEnumNumberMember": "const {assertEnumNumberMember} = types",
+    "assertEnumStringBody": "const {assertEnumStringBody} = types",
+    "assertEnumStringMember": "const {assertEnumStringMember} = types",
+    "assertEnumSymbolBody": "const {assertEnumSymbolBody} = types",
+    "assertExistsTypeAnnotation": "const {assertExistsTypeAnnotation} = types",
+    "assertExportAllDeclaration": "const {assertExportAllDeclaration} = types",
+    "assertExportDeclaration": "const {assertExportDeclaration} = types",
+    "assertExportDefaultDeclaration": "const {assertExportDefaultDeclaration} = types",
+    "assertExportDefaultSpecifier": "const {assertExportDefaultSpecifier} = types",
+    "assertExportNamedDeclaration": "const {assertExportNamedDeclaration} = types",
+    "assertExportNamespaceSpecifier": "const {assertExportNamespaceSpecifier} = types",
+    "assertExportSpecifier": "const {assertExportSpecifier} = types",
+    "assertExpression": "const {assertExpression} = types",
+    "assertExpressionStatement": "const {assertExpressionStatement} = types",
+    "assertExpressionWrapper": "const {assertExpressionWrapper} = types",
+    "assertFile": "const {assertFile} = types",
+    "assertFlow": "const {assertFlow} = types",
+    "assertFlowBaseAnnotation": "const {assertFlowBaseAnnotation} = types",
+    "assertFlowDeclaration": "const {assertFlowDeclaration} = types",
+    "assertFlowPredicate": "const {assertFlowPredicate} = types",
+    "assertFlowType": "const {assertFlowType} = types",
+    "assertFor": "const {assertFor} = types",
+    "assertForInStatement": "const {assertForInStatement} = types",
+    "assertForOfStatement": "const {assertForOfStatement} = types",
+    "assertForStatement": "const {assertForStatement} = types",
+    "assertForXStatement": "const {assertForXStatement} = types",
+    "assertFunction": "const {assertFunction} = types",
+    "assertFunctionDeclaration": "const {assertFunctionDeclaration} = types",
+    "assertFunctionExpression": "const {assertFunctionExpression} = types",
+    "assertFunctionParent": "const {assertFunctionParent} = types",
+    "assertFunctionTypeAnnotation": "const {assertFunctionTypeAnnotation} = types",
+    "assertFunctionTypeParam": "const {assertFunctionTypeParam} = types",
+    "assertGenericTypeAnnotation": "const {assertGenericTypeAnnotation} = types",
+    "assertIdentifier": "const {assertIdentifier} = types",
+    "assertIfStatement": "const {assertIfStatement} = types",
+    "assertImmutable": "const {assertImmutable} = types",
+    "assertImport": "const {assertImport} = types",
+    "assertImportAttribute": "const {assertImportAttribute} = types",
+    "assertImportDeclaration": "const {assertImportDeclaration} = types",
+    "assertImportDefaultSpecifier": "const {assertImportDefaultSpecifier} = types",
+    "assertImportExpression": "const {assertImportExpression} = types",
+    "assertImportNamespaceSpecifier": "const {assertImportNamespaceSpecifier} = types",
+    "assertImportOrExportDeclaration": "const {assertImportOrExportDeclaration} = types",
+    "assertImportSpecifier": "const {assertImportSpecifier} = types",
+    "assertIndexedAccessType": "const {assertIndexedAccessType} = types",
+    "assertInferredPredicate": "const {assertInferredPredicate} = types",
+    "assertInterfaceDeclaration": "const {assertInterfaceDeclaration} = types",
+    "assertInterfaceExtends": "const {assertInterfaceExtends} = types",
+    "assertInterfaceTypeAnnotation": "const {assertInterfaceTypeAnnotation} = types",
+    "assertInterpreterDirective": "const {assertInterpreterDirective} = types",
+    "assertIntersectionTypeAnnotation": "const {assertIntersectionTypeAnnotation} = types",
+    "assertJSX": "const {assertJSX} = types",
+    "assertJSXAttribute": "const {assertJSXAttribute} = types",
+    "assertJSXClosingElement": "const {assertJSXClosingElement} = types",
+    "assertJSXClosingFragment": "const {assertJSXClosingFragment} = types",
+    "assertJSXElement": "const {assertJSXElement} = types",
+    "assertJSXEmptyExpression": "const {assertJSXEmptyExpression} = types",
+    "assertJSXExpressionContainer": "const {assertJSXExpressionContainer} = types",
+    "assertJSXFragment": "const {assertJSXFragment} = types",
+    "assertJSXIdentifier": "const {assertJSXIdentifier} = types",
+    "assertJSXMemberExpression": "const {assertJSXMemberExpression} = types",
+    "assertJSXNamespacedName": "const {assertJSXNamespacedName} = types",
+    "assertJSXOpeningElement": "const {assertJSXOpeningElement} = types",
+    "assertJSXOpeningFragment": "const {assertJSXOpeningFragment} = types",
+    "assertJSXSpreadAttribute": "const {assertJSXSpreadAttribute} = types",
+    "assertJSXSpreadChild": "const {assertJSXSpreadChild} = types",
+    "assertJSXText": "const {assertJSXText} = types",
+    "assertLVal": "const {assertLVal} = types",
+    "assertLabeledStatement": "const {assertLabeledStatement} = types",
+    "assertLiteral": "const {assertLiteral} = types",
+    "assertLogicalExpression": "const {assertLogicalExpression} = types",
+    "assertLoop": "const {assertLoop} = types",
+    "assertMemberExpression": "const {assertMemberExpression} = types",
+    "assertMetaProperty": "const {assertMetaProperty} = types",
+    "assertMethod": "const {assertMethod} = types",
+    "assertMiscellaneous": "const {assertMiscellaneous} = types",
+    "assertMixedTypeAnnotation": "const {assertMixedTypeAnnotation} = types",
+    "assertModuleDeclaration": "const {assertModuleDeclaration} = types",
+    "assertModuleExpression": "const {assertModuleExpression} = types",
+    "assertModuleSpecifier": "const {assertModuleSpecifier} = types",
+    "assertNewExpression": "const {assertNewExpression} = types",
+    "assertNode": "const {assertNode} = types",
+    "assertNullLiteral": "const {assertNullLiteral} = types",
+    "assertNullLiteralTypeAnnotation": "const {assertNullLiteralTypeAnnotation} = types",
+    "assertNullableTypeAnnotation": "const {assertNullableTypeAnnotation} = types",
+    "assertNumberLiteral": "const {assertNumberLiteral} = types",
+    "assertNumberLiteralTypeAnnotation": "const {assertNumberLiteralTypeAnnotation} = types",
+    "assertNumberTypeAnnotation": "const {assertNumberTypeAnnotation} = types",
+    "assertNumericLiteral": "const {assertNumericLiteral} = types",
+    "assertObjectExpression": "const {assertObjectExpression} = types",
+    "assertObjectMember": "const {assertObjectMember} = types",
+    "assertObjectMethod": "const {assertObjectMethod} = types",
+    "assertObjectPattern": "const {assertObjectPattern} = types",
+    "assertObjectProperty": "const {assertObjectProperty} = types",
+    "assertObjectTypeAnnotation": "const {assertObjectTypeAnnotation} = types",
+    "assertObjectTypeCallProperty": "const {assertObjectTypeCallProperty} = types",
+    "assertObjectTypeIndexer": "const {assertObjectTypeIndexer} = types",
+    "assertObjectTypeInternalSlot": "const {assertObjectTypeInternalSlot} = types",
+    "assertObjectTypeProperty": "const {assertObjectTypeProperty} = types",
+    "assertObjectTypeSpreadProperty": "const {assertObjectTypeSpreadProperty} = types",
+    "assertOpaqueType": "const {assertOpaqueType} = types",
+    "assertOptionalCallExpression": "const {assertOptionalCallExpression} = types",
+    "assertOptionalIndexedAccessType": "const {assertOptionalIndexedAccessType} = types",
+    "assertOptionalMemberExpression": "const {assertOptionalMemberExpression} = types",
+    "assertParenthesizedExpression": "const {assertParenthesizedExpression} = types",
+    "assertPattern": "const {assertPattern} = types",
+    "assertPatternLike": "const {assertPatternLike} = types",
+    "assertPipelineBareFunction": "const {assertPipelineBareFunction} = types",
+    "assertPipelinePrimaryTopicReference": "const {assertPipelinePrimaryTopicReference} = types",
+    "assertPipelineTopicExpression": "const {assertPipelineTopicExpression} = types",
+    "assertPlaceholder": "const {assertPlaceholder} = types",
+    "assertPrivate": "const {assertPrivate} = types",
+    "assertPrivateName": "const {assertPrivateName} = types",
+    "assertProgram": "const {assertProgram} = types",
+    "assertProperty": "const {assertProperty} = types",
+    "assertPureish": "const {assertPureish} = types",
+    "assertQualifiedTypeIdentifier": "const {assertQualifiedTypeIdentifier} = types",
+    "assertRecordExpression": "const {assertRecordExpression} = types",
+    "assertRegExpLiteral": "const {assertRegExpLiteral} = types",
+    "assertRegexLiteral": "const {assertRegexLiteral} = types",
+    "assertRestElement": "const {assertRestElement} = types",
+    "assertRestProperty": "const {assertRestProperty} = types",
+    "assertReturnStatement": "const {assertReturnStatement} = types",
+    "assertScopable": "const {assertScopable} = types",
+    "assertSequenceExpression": "const {assertSequenceExpression} = types",
+    "assertSpreadElement": "const {assertSpreadElement} = types",
+    "assertSpreadProperty": "const {assertSpreadProperty} = types",
+    "assertStandardized": "const {assertStandardized} = types",
+    "assertStatement": "const {assertStatement} = types",
+    "assertStaticBlock": "const {assertStaticBlock} = types",
+    "assertStringLiteral": "const {assertStringLiteral} = types",
+    "assertStringLiteralTypeAnnotation": "const {assertStringLiteralTypeAnnotation} = types",
+    "assertStringTypeAnnotation": "const {assertStringTypeAnnotation} = types",
+    "assertSuper": "const {assertSuper} = types",
+    "assertSwitchCase": "const {assertSwitchCase} = types",
+    "assertSwitchStatement": "const {assertSwitchStatement} = types",
+    "assertSymbolTypeAnnotation": "const {assertSymbolTypeAnnotation} = types",
+    "assertTSAnyKeyword": "const {assertTSAnyKeyword} = types",
+    "assertTSArrayType": "const {assertTSArrayType} = types",
+    "assertTSAsExpression": "const {assertTSAsExpression} = types",
+    "assertTSBaseType": "const {assertTSBaseType} = types",
+    "assertTSBigIntKeyword": "const {assertTSBigIntKeyword} = types",
+    "assertTSBooleanKeyword": "const {assertTSBooleanKeyword} = types",
+    "assertTSCallSignatureDeclaration": "const {assertTSCallSignatureDeclaration} = types",
+    "assertTSClassImplements": "const {assertTSClassImplements} = types",
+    "assertTSConditionalType": "const {assertTSConditionalType} = types",
+    "assertTSConstructSignatureDeclaration": "const {assertTSConstructSignatureDeclaration} = types",
+    "assertTSConstructorType": "const {assertTSConstructorType} = types",
+    "assertTSDeclareFunction": "const {assertTSDeclareFunction} = types",
+    "assertTSDeclareMethod": "const {assertTSDeclareMethod} = types",
+    "assertTSEntityName": "const {assertTSEntityName} = types",
+    "assertTSEnumBody": "const {assertTSEnumBody} = types",
+    "assertTSEnumDeclaration": "const {assertTSEnumDeclaration} = types",
+    "assertTSEnumMember": "const {assertTSEnumMember} = types",
+    "assertTSExportAssignment": "const {assertTSExportAssignment} = types",
+    "assertTSExternalModuleReference": "const {assertTSExternalModuleReference} = types",
+    "assertTSFunctionType": "const {assertTSFunctionType} = types",
+    "assertTSImportEqualsDeclaration": "const {assertTSImportEqualsDeclaration} = types",
+    "assertTSImportType": "const {assertTSImportType} = types",
+    "assertTSIndexSignature": "const {assertTSIndexSignature} = types",
+    "assertTSIndexedAccessType": "const {assertTSIndexedAccessType} = types",
+    "assertTSInferType": "const {assertTSInferType} = types",
+    "assertTSInstantiationExpression": "const {assertTSInstantiationExpression} = types",
+    "assertTSInterfaceBody": "const {assertTSInterfaceBody} = types",
+    "assertTSInterfaceDeclaration": "const {assertTSInterfaceDeclaration} = types",
+    "assertTSInterfaceHeritage": "const {assertTSInterfaceHeritage} = types",
+    "assertTSIntersectionType": "const {assertTSIntersectionType} = types",
+    "assertTSIntrinsicKeyword": "const {assertTSIntrinsicKeyword} = types",
+    "assertTSLiteralType": "const {assertTSLiteralType} = types",
+    "assertTSMappedType": "const {assertTSMappedType} = types",
+    "assertTSMethodSignature": "const {assertTSMethodSignature} = types",
+    "assertTSModuleBlock": "const {assertTSModuleBlock} = types",
+    "assertTSModuleDeclaration": "const {assertTSModuleDeclaration} = types",
+    "assertTSNamedTupleMember": "const {assertTSNamedTupleMember} = types",
+    "assertTSNamespaceExportDeclaration": "const {assertTSNamespaceExportDeclaration} = types",
+    "assertTSNeverKeyword": "const {assertTSNeverKeyword} = types",
+    "assertTSNonNullExpression": "const {assertTSNonNullExpression} = types",
+    "assertTSNullKeyword": "const {assertTSNullKeyword} = types",
+    "assertTSNumberKeyword": "const {assertTSNumberKeyword} = types",
+    "assertTSObjectKeyword": "const {assertTSObjectKeyword} = types",
+    "assertTSOptionalType": "const {assertTSOptionalType} = types",
+    "assertTSParameterProperty": "const {assertTSParameterProperty} = types",
+    "assertTSParenthesizedType": "const {assertTSParenthesizedType} = types",
+    "assertTSPropertySignature": "const {assertTSPropertySignature} = types",
+    "assertTSQualifiedName": "const {assertTSQualifiedName} = types",
+    "assertTSRestType": "const {assertTSRestType} = types",
+    "assertTSSatisfiesExpression": "const {assertTSSatisfiesExpression} = types",
+    "assertTSStringKeyword": "const {assertTSStringKeyword} = types",
+    "assertTSSymbolKeyword": "const {assertTSSymbolKeyword} = types",
+    "assertTSTemplateLiteralType": "const {assertTSTemplateLiteralType} = types",
+    "assertTSThisType": "const {assertTSThisType} = types",
+    "assertTSTupleType": "const {assertTSTupleType} = types",
+    "assertTSType": "const {assertTSType} = types",
+    "assertTSTypeAliasDeclaration": "const {assertTSTypeAliasDeclaration} = types",
+    "assertTSTypeAnnotation": "const {assertTSTypeAnnotation} = types",
+    "assertTSTypeAssertion": "const {assertTSTypeAssertion} = types",
+    "assertTSTypeElement": "const {assertTSTypeElement} = types",
+    "assertTSTypeLiteral": "const {assertTSTypeLiteral} = types",
+    "assertTSTypeOperator": "const {assertTSTypeOperator} = types",
+    "assertTSTypeParameter": "const {assertTSTypeParameter} = types",
+    "assertTSTypeParameterDeclaration": "const {assertTSTypeParameterDeclaration} = types",
+    "assertTSTypeParameterInstantiation": "const {assertTSTypeParameterInstantiation} = types",
+    "assertTSTypePredicate": "const {assertTSTypePredicate} = types",
+    "assertTSTypeQuery": "const {assertTSTypeQuery} = types",
+    "assertTSTypeReference": "const {assertTSTypeReference} = types",
+    "assertTSUndefinedKeyword": "const {assertTSUndefinedKeyword} = types",
+    "assertTSUnionType": "const {assertTSUnionType} = types",
+    "assertTSUnknownKeyword": "const {assertTSUnknownKeyword} = types",
+    "assertTSVoidKeyword": "const {assertTSVoidKeyword} = types",
+    "assertTaggedTemplateExpression": "const {assertTaggedTemplateExpression} = types",
+    "assertTemplateElement": "const {assertTemplateElement} = types",
+    "assertTemplateLiteral": "const {assertTemplateLiteral} = types",
+    "assertTerminatorless": "const {assertTerminatorless} = types",
+    "assertThisExpression": "const {assertThisExpression} = types",
+    "assertThisTypeAnnotation": "const {assertThisTypeAnnotation} = types",
+    "assertThrowStatement": "const {assertThrowStatement} = types",
+    "assertTopicReference": "const {assertTopicReference} = types",
+    "assertTryStatement": "const {assertTryStatement} = types",
+    "assertTupleExpression": "const {assertTupleExpression} = types",
+    "assertTupleTypeAnnotation": "const {assertTupleTypeAnnotation} = types",
+    "assertTypeAlias": "const {assertTypeAlias} = types",
+    "assertTypeAnnotation": "const {assertTypeAnnotation} = types",
+    "assertTypeCastExpression": "const {assertTypeCastExpression} = types",
+    "assertTypeParameter": "const {assertTypeParameter} = types",
+    "assertTypeParameterDeclaration": "const {assertTypeParameterDeclaration} = types",
+    "assertTypeParameterInstantiation": "const {assertTypeParameterInstantiation} = types",
+    "assertTypeScript": "const {assertTypeScript} = types",
+    "assertTypeofTypeAnnotation": "const {assertTypeofTypeAnnotation} = types",
+    "assertUnaryExpression": "const {assertUnaryExpression} = types",
+    "assertUnaryLike": "const {assertUnaryLike} = types",
+    "assertUnionTypeAnnotation": "const {assertUnionTypeAnnotation} = types",
+    "assertUpdateExpression": "const {assertUpdateExpression} = types",
+    "assertUserWhitespacable": "const {assertUserWhitespacable} = types",
+    "assertV8IntrinsicIdentifier": "const {assertV8IntrinsicIdentifier} = types",
+    "assertVariableDeclaration": "const {assertVariableDeclaration} = types",
+    "assertVariableDeclarator": "const {assertVariableDeclarator} = types",
+    "assertVariance": "const {assertVariance} = types",
+    "assertVoidTypeAnnotation": "const {assertVoidTypeAnnotation} = types",
+    "assertWhile": "const {assertWhile} = types",
+    "assertWhileStatement": "const {assertWhileStatement} = types",
+    "assertWithStatement": "const {assertWithStatement} = types",
+    "assertYieldExpression": "const {assertYieldExpression} = types",
+    "assignmentExpression": "const {assignmentExpression} = types",
+    "assignmentPattern": "const {assignmentPattern} = types",
+    "awaitExpression": "const {awaitExpression} = types",
+    "bigIntLiteral": "const {bigIntLiteral} = types",
+    "binaryExpression": "const {binaryExpression} = types",
+    "bindExpression": "const {bindExpression} = types",
+    "blockStatement": "const {blockStatement} = types",
+    "booleanLiteral": "const {booleanLiteral} = types",
+    "booleanLiteralTypeAnnotation": "const {booleanLiteralTypeAnnotation} = types",
+    "booleanTypeAnnotation": "const {booleanTypeAnnotation} = types",
+    "breakStatement": "const {breakStatement} = types",
+    "buildMatchMemberExpression": "const {buildMatchMemberExpression} = types",
+    "buildUndefinedNode": "const {buildUndefinedNode} = types",
+    "callExpression": "const {callExpression} = types",
+    "catchClause": "const {catchClause} = types",
+    "classAccessorProperty": "const {classAccessorProperty} = types",
+    "classBody": "const {classBody} = types",
+    "classDeclaration": "const {classDeclaration} = types",
+    "classExpression": "const {classExpression} = types",
+    "classImplements": "const {classImplements} = types",
+    "classMethod": "const {classMethod} = types",
+    "classPrivateMethod": "const {classPrivateMethod} = types",
+    "classPrivateProperty": "const {classPrivateProperty} = types",
+    "classProperty": "const {classProperty} = types",
+    "clone": "const {clone} = types",
+    "cloneDeep": "const {cloneDeep} = types",
+    "cloneDeepWithoutLoc": "const {cloneDeepWithoutLoc} = types",
+    "cloneNode": "const {cloneNode} = types",
+    "cloneWithoutLoc": "const {cloneWithoutLoc} = types",
+    "conditionalExpression": "const {conditionalExpression} = types",
+    "continueStatement": "const {continueStatement} = types",
+    "createFlowUnionType": "const {createFlowUnionType} = types",
+    "createTSUnionType": "const {createTSUnionType} = types",
+    "createTypeAnnotationBasedOnTypeof": "const {createTypeAnnotationBasedOnTypeof} = types",
+    "createUnionTypeAnnotation": "const {createUnionTypeAnnotation} = types",
+    "debuggerStatement": "const {debuggerStatement} = types",
+    "declareClass": "const {declareClass} = types",
+    "declareExportAllDeclaration": "const {declareExportAllDeclaration} = types",
+    "declareExportDeclaration": "const {declareExportDeclaration} = types",
+    "declareFunction": "const {declareFunction} = types",
+    "declareInterface": "const {declareInterface} = types",
+    "declareModule": "const {declareModule} = types",
+    "declareModuleExports": "const {declareModuleExports} = types",
+    "declareOpaqueType": "const {declareOpaqueType} = types",
+    "declareTypeAlias": "const {declareTypeAlias} = types",
+    "declareVariable": "const {declareVariable} = types",
+    "declaredPredicate": "const {declaredPredicate} = types",
+    "decorator": "const {decorator} = types",
+    "directive": "const {directive} = types",
+    "directiveLiteral": "const {directiveLiteral} = types",
+    "doExpression": "const {doExpression} = types",
+    "doWhileStatement": "const {doWhileStatement} = types",
+    "emptyStatement": "const {emptyStatement} = types",
+    "emptyTypeAnnotation": "const {emptyTypeAnnotation} = types",
+    "ensureBlock": "const {ensureBlock} = types",
+    "enumBooleanBody": "const {enumBooleanBody} = types",
+    "enumBooleanMember": "const {enumBooleanMember} = types",
+    "enumDeclaration": "const {enumDeclaration} = types",
+    "enumDefaultedMember": "const {enumDefaultedMember} = types",
+    "enumNumberBody": "const {enumNumberBody} = types",
+    "enumNumberMember": "const {enumNumberMember} = types",
+    "enumStringBody": "const {enumStringBody} = types",
+    "enumStringMember": "const {enumStringMember} = types",
+    "enumSymbolBody": "const {enumSymbolBody} = types",
+    "existsTypeAnnotation": "const {existsTypeAnnotation} = types",
+    "exportAllDeclaration": "const {exportAllDeclaration} = types",
+    "exportDefaultDeclaration": "const {exportDefaultDeclaration} = types",
+    "exportDefaultSpecifier": "const {exportDefaultSpecifier} = types",
+    "exportNamedDeclaration": "const {exportNamedDeclaration} = types",
+    "exportNamespaceSpecifier": "const {exportNamespaceSpecifier} = types",
+    "exportSpecifier": "const {exportSpecifier} = types",
+    "expressionStatement": "const {expressionStatement} = types",
+    "file": "const {file} = types",
+    "forInStatement": "const {forInStatement} = types",
+    "forOfStatement": "const {forOfStatement} = types",
+    "forStatement": "const {forStatement} = types",
+    "functionDeclaration": "const {functionDeclaration} = types",
+    "functionExpression": "const {functionExpression} = types",
+    "functionTypeAnnotation": "const {functionTypeAnnotation} = types",
+    "functionTypeParam": "const {functionTypeParam} = types",
+    "genericTypeAnnotation": "const {genericTypeAnnotation} = types",
+    "getAssignmentIdentifiers": "const {getAssignmentIdentifiers} = types",
+    "getBindingIdentifiers": "const {getBindingIdentifiers} = types",
+    "getFunctionName": "const {getFunctionName} = types",
+    "getOuterBindingIdentifiers": "const {getOuterBindingIdentifiers} = types",
+    "identifier": "const {identifier} = types",
+    "ifStatement": "const {ifStatement} = types",
+    "import": "const {import} = types",
+    "importAttribute": "const {importAttribute} = types",
+    "importDeclaration": "const {importDeclaration} = types",
+    "importDefaultSpecifier": "const {importDefaultSpecifier} = types",
+    "importExpression": "const {importExpression} = types",
+    "importNamespaceSpecifier": "const {importNamespaceSpecifier} = types",
+    "importSpecifier": "const {importSpecifier} = types",
+    "indexedAccessType": "const {indexedAccessType} = types",
+    "inferredPredicate": "const {inferredPredicate} = types",
+    "inheritInnerComments": "const {inheritInnerComments} = types",
+    "inheritLeadingComments": "const {inheritLeadingComments} = types",
+    "inheritTrailingComments": "const {inheritTrailingComments} = types",
+    "inherits": "const {inherits} = types",
+    "inheritsComments": "const {inheritsComments} = types",
+    "interfaceDeclaration": "const {interfaceDeclaration} = types",
+    "interfaceExtends": "const {interfaceExtends} = types",
+    "interfaceTypeAnnotation": "const {interfaceTypeAnnotation} = types",
+    "interpreterDirective": "const {interpreterDirective} = types",
+    "intersectionTypeAnnotation": "const {intersectionTypeAnnotation} = types",
     "isAccessor": "const {isAccessor} = types",
     "isAnyTypeAnnotation": "const {isAnyTypeAnnotation} = types",
     "isArgumentPlaceholder": "const {isArgumentPlaceholder} = types",
@@ -475,6 +898,7 @@
     "isTSDeclareFunction": "const {isTSDeclareFunction} = types",
     "isTSDeclareMethod": "const {isTSDeclareMethod} = types",
     "isTSEntityName": "const {isTSEntityName} = types",
+    "isTSEnumBody": "const {isTSEnumBody} = types",
     "isTSEnumDeclaration": "const {isTSEnumDeclaration} = types",
     "isTSEnumMember": "const {isTSEnumMember} = types",
     "isTSExportAssignment": "const {isTSExportAssignment} = types",
@@ -512,6 +936,7 @@
     "isTSSatisfiesExpression": "const {isTSSatisfiesExpression} = types",
     "isTSStringKeyword": "const {isTSStringKeyword} = types",
     "isTSSymbolKeyword": "const {isTSSymbolKeyword} = types",
+    "isTSTemplateLiteralType": "const {isTSTemplateLiteralType} = types",
     "isTSThisType": "const {isTSThisType} = types",
     "isTSTupleType": "const {isTSTupleType} = types",
     "isTSType": "const {isTSType} = types",
@@ -567,5 +992,188 @@
     "isWhile": "const {isWhile} = types",
     "isWhileStatement": "const {isWhileStatement} = types",
     "isWithStatement": "const {isWithStatement} = types",
-    "isYieldExpression": "const {isYieldExpression} = types"
+    "isYieldExpression": "const {isYieldExpression} = types",
+    "jsxAttribute": "const {jsxAttribute} = types",
+    "jsxClosingElement": "const {jsxClosingElement} = types",
+    "jsxClosingFragment": "const {jsxClosingFragment} = types",
+    "jsxElement": "const {jsxElement} = types",
+    "jsxEmptyExpression": "const {jsxEmptyExpression} = types",
+    "jsxExpressionContainer": "const {jsxExpressionContainer} = types",
+    "jsxFragment": "const {jsxFragment} = types",
+    "jsxIdentifier": "const {jsxIdentifier} = types",
+    "jsxMemberExpression": "const {jsxMemberExpression} = types",
+    "jsxNamespacedName": "const {jsxNamespacedName} = types",
+    "jsxOpeningElement": "const {jsxOpeningElement} = types",
+    "jsxOpeningFragment": "const {jsxOpeningFragment} = types",
+    "jsxSpreadAttribute": "const {jsxSpreadAttribute} = types",
+    "jsxSpreadChild": "const {jsxSpreadChild} = types",
+    "jsxText": "const {jsxText} = types",
+    "labeledStatement": "const {labeledStatement} = types",
+    "logicalExpression": "const {logicalExpression} = types",
+    "matchesPattern": "const {matchesPattern} = types",
+    "memberExpression": "const {memberExpression} = types",
+    "metaProperty": "const {metaProperty} = types",
+    "mixedTypeAnnotation": "const {mixedTypeAnnotation} = types",
+    "moduleExpression": "const {moduleExpression} = types",
+    "newExpression": "const {newExpression} = types",
+    "nullLiteral": "const {nullLiteral} = types",
+    "nullLiteralTypeAnnotation": "const {nullLiteralTypeAnnotation} = types",
+    "nullableTypeAnnotation": "const {nullableTypeAnnotation} = types",
+    "numberLiteral": "const {numberLiteral} = types",
+    "numberLiteralTypeAnnotation": "const {numberLiteralTypeAnnotation} = types",
+    "numberTypeAnnotation": "const {numberTypeAnnotation} = types",
+    "numericLiteral": "const {numericLiteral} = types",
+    "objectExpression": "const {objectExpression} = types",
+    "objectMethod": "const {objectMethod} = types",
+    "objectPattern": "const {objectPattern} = types",
+    "objectProperty": "const {objectProperty} = types",
+    "objectTypeAnnotation": "const {objectTypeAnnotation} = types",
+    "objectTypeCallProperty": "const {objectTypeCallProperty} = types",
+    "objectTypeIndexer": "const {objectTypeIndexer} = types",
+    "objectTypeInternalSlot": "const {objectTypeInternalSlot} = types",
+    "objectTypeProperty": "const {objectTypeProperty} = types",
+    "objectTypeSpreadProperty": "const {objectTypeSpreadProperty} = types",
+    "opaqueType": "const {opaqueType} = types",
+    "optionalCallExpression": "const {optionalCallExpression} = types",
+    "optionalIndexedAccessType": "const {optionalIndexedAccessType} = types",
+    "optionalMemberExpression": "const {optionalMemberExpression} = types",
+    "parenthesizedExpression": "const {parenthesizedExpression} = types",
+    "pipelineBareFunction": "const {pipelineBareFunction} = types",
+    "pipelinePrimaryTopicReference": "const {pipelinePrimaryTopicReference} = types",
+    "pipelineTopicExpression": "const {pipelineTopicExpression} = types",
+    "placeholder": "const {placeholder} = types",
+    "prependToMemberExpression": "const {prependToMemberExpression} = types",
+    "privateName": "const {privateName} = types",
+    "program": "const {program} = types",
+    "qualifiedTypeIdentifier": "const {qualifiedTypeIdentifier} = types",
+    "react": "const {react} = types",
+    "recordExpression": "const {recordExpression} = types",
+    "regExpLiteral": "const {regExpLiteral} = types",
+    "regexLiteral": "const {regexLiteral} = types",
+    "removeComments": "const {removeComments} = types",
+    "removeProperties": "const {removeProperties} = types",
+    "removePropertiesDeep": "const {removePropertiesDeep} = types",
+    "removeTypeDuplicates": "const {removeTypeDuplicates} = types",
+    "restElement": "const {restElement} = types",
+    "restProperty": "const {restProperty} = types",
+    "returnStatement": "const {returnStatement} = types",
+    "sequenceExpression": "const {sequenceExpression} = types",
+    "shallowEqual": "const {shallowEqual} = types",
+    "spreadElement": "const {spreadElement} = types",
+    "spreadProperty": "const {spreadProperty} = types",
+    "staticBlock": "const {staticBlock} = types",
+    "stringLiteral": "const {stringLiteral} = types",
+    "stringLiteralTypeAnnotation": "const {stringLiteralTypeAnnotation} = types",
+    "stringTypeAnnotation": "const {stringTypeAnnotation} = types",
+    "super": "const {super} = types",
+    "switchCase": "const {switchCase} = types",
+    "switchStatement": "const {switchStatement} = types",
+    "symbolTypeAnnotation": "const {symbolTypeAnnotation} = types",
+    "taggedTemplateExpression": "const {taggedTemplateExpression} = types",
+    "templateElement": "const {templateElement} = types",
+    "templateLiteral": "const {templateLiteral} = types",
+    "thisExpression": "const {thisExpression} = types",
+    "thisTypeAnnotation": "const {thisTypeAnnotation} = types",
+    "throwStatement": "const {throwStatement} = types",
+    "toBindingIdentifierName": "const {toBindingIdentifierName} = types",
+    "toBlock": "const {toBlock} = types",
+    "toComputedKey": "const {toComputedKey} = types",
+    "toExpression": "const {toExpression} = types",
+    "toIdentifier": "const {toIdentifier} = types",
+    "toKeyAlias": "const {toKeyAlias} = types",
+    "toStatement": "const {toStatement} = types",
+    "topicReference": "const {topicReference} = types",
+    "traverse": "const {traverse} = types",
+    "traverseFast": "const {traverseFast} = types",
+    "tryStatement": "const {tryStatement} = types",
+    "tsAnyKeyword": "const {tsAnyKeyword} = types",
+    "tsArrayType": "const {tsArrayType} = types",
+    "tsAsExpression": "const {tsAsExpression} = types",
+    "tsBigIntKeyword": "const {tsBigIntKeyword} = types",
+    "tsBooleanKeyword": "const {tsBooleanKeyword} = types",
+    "tsCallSignatureDeclaration": "const {tsCallSignatureDeclaration} = types",
+    "tsClassImplements": "const {tsClassImplements} = types",
+    "tsConditionalType": "const {tsConditionalType} = types",
+    "tsConstructSignatureDeclaration": "const {tsConstructSignatureDeclaration} = types",
+    "tsConstructorType": "const {tsConstructorType} = types",
+    "tsDeclareFunction": "const {tsDeclareFunction} = types",
+    "tsDeclareMethod": "const {tsDeclareMethod} = types",
+    "tsEnumBody": "const {tsEnumBody} = types",
+    "tsEnumDeclaration": "const {tsEnumDeclaration} = types",
+    "tsEnumMember": "const {tsEnumMember} = types",
+    "tsExportAssignment": "const {tsExportAssignment} = types",
+    "tsExternalModuleReference": "const {tsExternalModuleReference} = types",
+    "tsFunctionType": "const {tsFunctionType} = types",
+    "tsImportEqualsDeclaration": "const {tsImportEqualsDeclaration} = types",
+    "tsImportType": "const {tsImportType} = types",
+    "tsIndexSignature": "const {tsIndexSignature} = types",
+    "tsIndexedAccessType": "const {tsIndexedAccessType} = types",
+    "tsInferType": "const {tsInferType} = types",
+    "tsInstantiationExpression": "const {tsInstantiationExpression} = types",
+    "tsInterfaceBody": "const {tsInterfaceBody} = types",
+    "tsInterfaceDeclaration": "const {tsInterfaceDeclaration} = types",
+    "tsInterfaceHeritage": "const {tsInterfaceHeritage} = types",
+    "tsIntersectionType": "const {tsIntersectionType} = types",
+    "tsIntrinsicKeyword": "const {tsIntrinsicKeyword} = types",
+    "tsLiteralType": "const {tsLiteralType} = types",
+    "tsMappedType": "const {tsMappedType} = types",
+    "tsMethodSignature": "const {tsMethodSignature} = types",
+    "tsModuleBlock": "const {tsModuleBlock} = types",
+    "tsModuleDeclaration": "const {tsModuleDeclaration} = types",
+    "tsNamedTupleMember": "const {tsNamedTupleMember} = types",
+    "tsNamespaceExportDeclaration": "const {tsNamespaceExportDeclaration} = types",
+    "tsNeverKeyword": "const {tsNeverKeyword} = types",
+    "tsNonNullExpression": "const {tsNonNullExpression} = types",
+    "tsNullKeyword": "const {tsNullKeyword} = types",
+    "tsNumberKeyword": "const {tsNumberKeyword} = types",
+    "tsObjectKeyword": "const {tsObjectKeyword} = types",
+    "tsOptionalType": "const {tsOptionalType} = types",
+    "tsParameterProperty": "const {tsParameterProperty} = types",
+    "tsParenthesizedType": "const {tsParenthesizedType} = types",
+    "tsPropertySignature": "const {tsPropertySignature} = types",
+    "tsQualifiedName": "const {tsQualifiedName} = types",
+    "tsRestType": "const {tsRestType} = types",
+    "tsSatisfiesExpression": "const {tsSatisfiesExpression} = types",
+    "tsStringKeyword": "const {tsStringKeyword} = types",
+    "tsSymbolKeyword": "const {tsSymbolKeyword} = types",
+    "tsTemplateLiteralType": "const {tsTemplateLiteralType} = types",
+    "tsThisType": "const {tsThisType} = types",
+    "tsTupleType": "const {tsTupleType} = types",
+    "tsTypeAliasDeclaration": "const {tsTypeAliasDeclaration} = types",
+    "tsTypeAnnotation": "const {tsTypeAnnotation} = types",
+    "tsTypeAssertion": "const {tsTypeAssertion} = types",
+    "tsTypeLiteral": "const {tsTypeLiteral} = types",
+    "tsTypeOperator": "const {tsTypeOperator} = types",
+    "tsTypeParameter": "const {tsTypeParameter} = types",
+    "tsTypeParameterDeclaration": "const {tsTypeParameterDeclaration} = types",
+    "tsTypeParameterInstantiation": "const {tsTypeParameterInstantiation} = types",
+    "tsTypePredicate": "const {tsTypePredicate} = types",
+    "tsTypeQuery": "const {tsTypeQuery} = types",
+    "tsTypeReference": "const {tsTypeReference} = types",
+    "tsUndefinedKeyword": "const {tsUndefinedKeyword} = types",
+    "tsUnionType": "const {tsUnionType} = types",
+    "tsUnknownKeyword": "const {tsUnknownKeyword} = types",
+    "tsVoidKeyword": "const {tsVoidKeyword} = types",
+    "tupleExpression": "const {tupleExpression} = types",
+    "tupleTypeAnnotation": "const {tupleTypeAnnotation} = types",
+    "typeAlias": "const {typeAlias} = types",
+    "typeAnnotation": "const {typeAnnotation} = types",
+    "typeCastExpression": "const {typeCastExpression} = types",
+    "typeParameter": "const {typeParameter} = types",
+    "typeParameterDeclaration": "const {typeParameterDeclaration} = types",
+    "typeParameterInstantiation": "const {typeParameterInstantiation} = types",
+    "typeofTypeAnnotation": "const {typeofTypeAnnotation} = types",
+    "unaryExpression": "const {unaryExpression} = types",
+    "unionTypeAnnotation": "const {unionTypeAnnotation} = types",
+    "updateExpression": "const {updateExpression} = types",
+    "v8IntrinsicIdentifier": "const {v8IntrinsicIdentifier} = types",
+    "validate": "const {validate} = types",
+    "valueToNode": "const {valueToNode} = types",
+    "variableDeclaration": "const {variableDeclaration} = types",
+    "variableDeclarator": "const {variableDeclarator} = types",
+    "variance": "const {variance} = types",
+    "voidTypeAnnotation": "const {voidTypeAnnotation} = types",
+    "whileStatement": "const {whileStatement} = types",
+    "withStatement": "const {withStatement} = types",
+    "yieldExpression": "const {yieldExpression} = types"
 }