@putout/plugin-putout 23.15.1 → 24.0.0

package/lib/declare/types.js

@@ -0,0 +1,1179 @@
+export default {
+    AnyTypeAnnotation: 'const {AnyTypeAnnotation} = types',
+    ArgumentPlaceholder: 'const {ArgumentPlaceholder} = types',
+    ArrayExpression: 'const {ArrayExpression} = types',
+    ArrayPattern: 'const {ArrayPattern} = types',
+    ArrayTypeAnnotation: 'const {ArrayTypeAnnotation} = types',
+    ArrowFunctionExpression: 'const {ArrowFunctionExpression} = 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',
+    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',
+    ConditionalExpression: 'const {ConditionalExpression} = types',
+    ContinueStatement: 'const {ContinueStatement} = 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',
+    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',
+    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',
+    InterfaceDeclaration: 'const {InterfaceDeclaration} = types',
+    InterfaceExtends: 'const {InterfaceExtends} = types',
+    InterfaceTypeAnnotation: 'const {InterfaceTypeAnnotation} = types',
+    InterpreterDirective: 'const {InterpreterDirective} = types',
+    IntersectionTypeAnnotation: 'const {IntersectionTypeAnnotation} = 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',
+    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',
+    PrivateName: 'const {PrivateName} = types',
+    Program: 'const {Program} = types',
+    QualifiedTypeIdentifier: 'const {QualifiedTypeIdentifier} = types',
+    RecordExpression: 'const {RecordExpression} = types',
+    RegExpLiteral: 'const {RegExpLiteral} = types',
+    RegexLiteral: 'const {RegexLiteral} = types',
+    RestElement: 'const {RestElement} = types',
+    RestProperty: 'const {RestProperty} = types',
+    ReturnStatement: 'const {ReturnStatement} = types',
+    SequenceExpression: 'const {SequenceExpression} = 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',
+    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',
+    TaggedTemplateExpression: 'const {TaggedTemplateExpression} = types',
+    TemplateElement: 'const {TemplateElement} = types',
+    TemplateLiteral: 'const {TemplateLiteral} = types',
+    ThisExpression: 'const {ThisExpression} = types',
+    ThisTypeAnnotation: 'const {ThisTypeAnnotation} = types',
+    ThrowStatement: 'const {ThrowStatement} = types',
+    TopicReference: 'const {TopicReference} = types',
+    TryStatement: 'const {TryStatement} = 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',
+    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',
+    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',
+    isArrayExpression: 'const {isArrayExpression} = types',
+    isArrayPattern: 'const {isArrayPattern} = types',
+    isArrayTypeAnnotation: 'const {isArrayTypeAnnotation} = types',
+    isArrowFunctionExpression: 'const {isArrowFunctionExpression} = types',
+    isAssignmentExpression: 'const {isAssignmentExpression} = types',
+    isAssignmentPattern: 'const {isAssignmentPattern} = types',
+    isAwaitExpression: 'const {isAwaitExpression} = types',
+    isBigIntLiteral: 'const {isBigIntLiteral} = types',
+    isBinary: 'const {isBinary} = types',
+    isBinaryExpression: 'const {isBinaryExpression} = types',
+    isBindExpression: 'const {isBindExpression} = types',
+    isBinding: 'const {isBinding} = types',
+    isBlock: 'const {isBlock} = types',
+    isBlockParent: 'const {isBlockParent} = types',
+    isBlockScoped: 'const {isBlockScoped} = types',
+    isBlockStatement: 'const {isBlockStatement} = types',
+    isBooleanLiteral: 'const {isBooleanLiteral} = types',
+    isBooleanLiteralTypeAnnotation: 'const {isBooleanLiteralTypeAnnotation} = types',
+    isBooleanTypeAnnotation: 'const {isBooleanTypeAnnotation} = types',
+    isBreakStatement: 'const {isBreakStatement} = types',
+    isCallExpression: 'const {isCallExpression} = types',
+    isCatchClause: 'const {isCatchClause} = types',
+    isClass: 'const {isClass} = types',
+    isClassAccessorProperty: 'const {isClassAccessorProperty} = types',
+    isClassBody: 'const {isClassBody} = types',
+    isClassDeclaration: 'const {isClassDeclaration} = types',
+    isClassExpression: 'const {isClassExpression} = types',
+    isClassImplements: 'const {isClassImplements} = types',
+    isClassMethod: 'const {isClassMethod} = types',
+    isClassPrivateMethod: 'const {isClassPrivateMethod} = types',
+    isClassPrivateProperty: 'const {isClassPrivateProperty} = types',
+    isClassProperty: 'const {isClassProperty} = types',
+    isCompletionStatement: 'const {isCompletionStatement} = types',
+    isConditional: 'const {isConditional} = types',
+    isConditionalExpression: 'const {isConditionalExpression} = types',
+    isContinueStatement: 'const {isContinueStatement} = types',
+    isDebuggerStatement: 'const {isDebuggerStatement} = types',
+    isDeclaration: 'const {isDeclaration} = types',
+    isDeclareClass: 'const {isDeclareClass} = types',
+    isDeclareExportAllDeclaration: 'const {isDeclareExportAllDeclaration} = types',
+    isDeclareExportDeclaration: 'const {isDeclareExportDeclaration} = types',
+    isDeclareFunction: 'const {isDeclareFunction} = types',
+    isDeclareInterface: 'const {isDeclareInterface} = types',
+    isDeclareModule: 'const {isDeclareModule} = types',
+    isDeclareModuleExports: 'const {isDeclareModuleExports} = types',
+    isDeclareOpaqueType: 'const {isDeclareOpaqueType} = types',
+    isDeclareTypeAlias: 'const {isDeclareTypeAlias} = types',
+    isDeclareVariable: 'const {isDeclareVariable} = types',
+    isDeclaredPredicate: 'const {isDeclaredPredicate} = types',
+    isDecorator: 'const {isDecorator} = types',
+    isDirective: 'const {isDirective} = types',
+    isDirectiveLiteral: 'const {isDirectiveLiteral} = types',
+    isDoExpression: 'const {isDoExpression} = types',
+    isDoWhileStatement: 'const {isDoWhileStatement} = types',
+    isEmptyStatement: 'const {isEmptyStatement} = types',
+    isEmptyTypeAnnotation: 'const {isEmptyTypeAnnotation} = types',
+    isEnumBody: 'const {isEnumBody} = types',
+    isEnumBooleanBody: 'const {isEnumBooleanBody} = types',
+    isEnumBooleanMember: 'const {isEnumBooleanMember} = types',
+    isEnumDeclaration: 'const {isEnumDeclaration} = types',
+    isEnumDefaultedMember: 'const {isEnumDefaultedMember} = types',
+    isEnumMember: 'const {isEnumMember} = types',
+    isEnumNumberBody: 'const {isEnumNumberBody} = types',
+    isEnumNumberMember: 'const {isEnumNumberMember} = types',
+    isEnumStringBody: 'const {isEnumStringBody} = types',
+    isEnumStringMember: 'const {isEnumStringMember} = types',
+    isEnumSymbolBody: 'const {isEnumSymbolBody} = types',
+    isExistsTypeAnnotation: 'const {isExistsTypeAnnotation} = types',
+    isExportAllDeclaration: 'const {isExportAllDeclaration} = types',
+    isExportDeclaration: 'const {isExportDeclaration} = types',
+    isExportDefaultDeclaration: 'const {isExportDefaultDeclaration} = types',
+    isExportDefaultSpecifier: 'const {isExportDefaultSpecifier} = types',
+    isExportNamedDeclaration: 'const {isExportNamedDeclaration} = types',
+    isExportNamespaceSpecifier: 'const {isExportNamespaceSpecifier} = types',
+    isExportSpecifier: 'const {isExportSpecifier} = types',
+    isExpression: 'const {isExpression} = types',
+    isExpressionStatement: 'const {isExpressionStatement} = types',
+    isExpressionWrapper: 'const {isExpressionWrapper} = types',
+    isFile: 'const {isFile} = types',
+    isFlow: 'const {isFlow} = types',
+    isFlowBaseAnnotation: 'const {isFlowBaseAnnotation} = types',
+    isFlowDeclaration: 'const {isFlowDeclaration} = types',
+    isFlowPredicate: 'const {isFlowPredicate} = types',
+    isFlowType: 'const {isFlowType} = types',
+    isFor: 'const {isFor} = types',
+    isForInStatement: 'const {isForInStatement} = types',
+    isForOfStatement: 'const {isForOfStatement} = types',
+    isForStatement: 'const {isForStatement} = types',
+    isForXStatement: 'const {isForXStatement} = types',
+    isFunction: 'const {isFunction} = types',
+    isFunctionDeclaration: 'const {isFunctionDeclaration} = types',
+    isFunctionExpression: 'const {isFunctionExpression} = types',
+    isFunctionParent: 'const {isFunctionParent} = types',
+    isFunctionTypeAnnotation: 'const {isFunctionTypeAnnotation} = types',
+    isFunctionTypeParam: 'const {isFunctionTypeParam} = types',
+    isGenericTypeAnnotation: 'const {isGenericTypeAnnotation} = types',
+    isIdentifier: 'const {isIdentifier} = types',
+    isIfStatement: 'const {isIfStatement} = types',
+    isImmutable: 'const {isImmutable} = types',
+    isImport: 'const {isImport} = types',
+    isImportAttribute: 'const {isImportAttribute} = types',
+    isImportDeclaration: 'const {isImportDeclaration} = types',
+    isImportDefaultSpecifier: 'const {isImportDefaultSpecifier} = types',
+    isImportExpression: 'const {isImportExpression} = types',
+    isImportNamespaceSpecifier: 'const {isImportNamespaceSpecifier} = types',
+    isImportOrExportDeclaration: 'const {isImportOrExportDeclaration} = types',
+    isImportSpecifier: 'const {isImportSpecifier} = types',
+    isIndexedAccessType: 'const {isIndexedAccessType} = types',
+    isInferredPredicate: 'const {isInferredPredicate} = types',
+    isInterfaceDeclaration: 'const {isInterfaceDeclaration} = types',
+    isInterfaceExtends: 'const {isInterfaceExtends} = types',
+    isInterfaceTypeAnnotation: 'const {isInterfaceTypeAnnotation} = types',
+    isInterpreterDirective: 'const {isInterpreterDirective} = types',
+    isIntersectionTypeAnnotation: 'const {isIntersectionTypeAnnotation} = types',
+    isJSX: 'const {isJSX} = types',
+    isJSXAttribute: 'const {isJSXAttribute} = types',
+    isJSXClosingElement: 'const {isJSXClosingElement} = types',
+    isJSXClosingFragment: 'const {isJSXClosingFragment} = types',
+    isJSXElement: 'const {isJSXElement} = types',
+    isJSXEmptyExpression: 'const {isJSXEmptyExpression} = types',
+    isJSXExpressionContainer: 'const {isJSXExpressionContainer} = types',
+    isJSXFragment: 'const {isJSXFragment} = types',
+    isJSXIdentifier: 'const {isJSXIdentifier} = types',
+    isJSXMemberExpression: 'const {isJSXMemberExpression} = types',
+    isJSXNamespacedName: 'const {isJSXNamespacedName} = types',
+    isJSXOpeningElement: 'const {isJSXOpeningElement} = types',
+    isJSXOpeningFragment: 'const {isJSXOpeningFragment} = types',
+    isJSXSpreadAttribute: 'const {isJSXSpreadAttribute} = types',
+    isJSXSpreadChild: 'const {isJSXSpreadChild} = types',
+    isJSXText: 'const {isJSXText} = types',
+    isLVal: 'const {isLVal} = types',
+    isLabeledStatement: 'const {isLabeledStatement} = types',
+    isLet: 'const {isLet} = types',
+    isLiteral: 'const {isLiteral} = types',
+    isLogicalExpression: 'const {isLogicalExpression} = types',
+    isLoop: 'const {isLoop} = types',
+    isMemberExpression: 'const {isMemberExpression} = types',
+    isMetaProperty: 'const {isMetaProperty} = types',
+    isMethod: 'const {isMethod} = types',
+    isMiscellaneous: 'const {isMiscellaneous} = types',
+    isMixedTypeAnnotation: 'const {isMixedTypeAnnotation} = types',
+    isModuleDeclaration: 'const {isModuleDeclaration} = types',
+    isModuleExpression: 'const {isModuleExpression} = types',
+    isModuleSpecifier: 'const {isModuleSpecifier} = types',
+    isNewExpression: 'const {isNewExpression} = types',
+    isNode: 'const {isNode} = types',
+    isNodesEquivalent: 'const {isNodesEquivalent} = types',
+    isNullLiteral: 'const {isNullLiteral} = types',
+    isNullLiteralTypeAnnotation: 'const {isNullLiteralTypeAnnotation} = types',
+    isNullableTypeAnnotation: 'const {isNullableTypeAnnotation} = types',
+    isNumberLiteral: 'const {isNumberLiteral} = types',
+    isNumberLiteralTypeAnnotation: 'const {isNumberLiteralTypeAnnotation} = types',
+    isNumberTypeAnnotation: 'const {isNumberTypeAnnotation} = types',
+    isNumericLiteral: 'const {isNumericLiteral} = types',
+    isObjectExpression: 'const {isObjectExpression} = types',
+    isObjectMember: 'const {isObjectMember} = types',
+    isObjectMethod: 'const {isObjectMethod} = types',
+    isObjectPattern: 'const {isObjectPattern} = types',
+    isObjectProperty: 'const {isObjectProperty} = types',
+    isObjectTypeAnnotation: 'const {isObjectTypeAnnotation} = types',
+    isObjectTypeCallProperty: 'const {isObjectTypeCallProperty} = types',
+    isObjectTypeIndexer: 'const {isObjectTypeIndexer} = types',
+    isObjectTypeInternalSlot: 'const {isObjectTypeInternalSlot} = types',
+    isObjectTypeProperty: 'const {isObjectTypeProperty} = types',
+    isObjectTypeSpreadProperty: 'const {isObjectTypeSpreadProperty} = types',
+    isOpaqueType: 'const {isOpaqueType} = types',
+    isOptionalCallExpression: 'const {isOptionalCallExpression} = types',
+    isOptionalIndexedAccessType: 'const {isOptionalIndexedAccessType} = types',
+    isOptionalMemberExpression: 'const {isOptionalMemberExpression} = types',
+    isParenthesizedExpression: 'const {isParenthesizedExpression} = types',
+    isPattern: 'const {isPattern} = types',
+    isPatternLike: 'const {isPatternLike} = types',
+    isPipelineBareFunction: 'const {isPipelineBareFunction} = types',
+    isPipelinePrimaryTopicReference: 'const {isPipelinePrimaryTopicReference} = types',
+    isPipelineTopicExpression: 'const {isPipelineTopicExpression} = types',
+    isPlaceholder: 'const {isPlaceholder} = types',
+    isPlaceholderType: 'const {isPlaceholderType} = types',
+    isPrivate: 'const {isPrivate} = types',
+    isPrivateName: 'const {isPrivateName} = types',
+    isProgram: 'const {isProgram} = types',
+    isProperty: 'const {isProperty} = types',
+    isPureish: 'const {isPureish} = types',
+    isQualifiedTypeIdentifier: 'const {isQualifiedTypeIdentifier} = types',
+    isRecordExpression: 'const {isRecordExpression} = types',
+    isReferenced: 'const {isReferenced} = types',
+    isRegExpLiteral: 'const {isRegExpLiteral} = types',
+    isRegexLiteral: 'const {isRegexLiteral} = types',
+    isRestElement: 'const {isRestElement} = types',
+    isRestProperty: 'const {isRestProperty} = types',
+    isReturnStatement: 'const {isReturnStatement} = types',
+    isScopable: 'const {isScopable} = types',
+    isScope: 'const {isScope} = types',
+    isSequenceExpression: 'const {isSequenceExpression} = types',
+    isSpecifierDefault: 'const {isSpecifierDefault} = types',
+    isSpreadElement: 'const {isSpreadElement} = types',
+    isSpreadProperty: 'const {isSpreadProperty} = types',
+    isStandardized: 'const {isStandardized} = types',
+    isStatement: 'const {isStatement} = types',
+    isStaticBlock: 'const {isStaticBlock} = types',
+    isStringLiteral: 'const {isStringLiteral} = types',
+    isStringLiteralTypeAnnotation: 'const {isStringLiteralTypeAnnotation} = types',
+    isStringTypeAnnotation: 'const {isStringTypeAnnotation} = types',
+    isSuper: 'const {isSuper} = types',
+    isSwitchCase: 'const {isSwitchCase} = types',
+    isSwitchStatement: 'const {isSwitchStatement} = types',
+    isSymbolTypeAnnotation: 'const {isSymbolTypeAnnotation} = types',
+    isTSAnyKeyword: 'const {isTSAnyKeyword} = types',
+    isTSArrayType: 'const {isTSArrayType} = types',
+    isTSAsExpression: 'const {isTSAsExpression} = types',
+    isTSBaseType: 'const {isTSBaseType} = types',
+    isTSBigIntKeyword: 'const {isTSBigIntKeyword} = types',
+    isTSBooleanKeyword: 'const {isTSBooleanKeyword} = types',
+    isTSCallSignatureDeclaration: 'const {isTSCallSignatureDeclaration} = types',
+    isTSClassImplements: 'const {isTSClassImplements} = types',
+    isTSConditionalType: 'const {isTSConditionalType} = types',
+    isTSConstructSignatureDeclaration: 'const {isTSConstructSignatureDeclaration} = types',
+    isTSConstructorType: 'const {isTSConstructorType} = types',
+    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',
+    isTSExternalModuleReference: 'const {isTSExternalModuleReference} = types',
+    isTSFunctionType: 'const {isTSFunctionType} = types',
+    isTSImportEqualsDeclaration: 'const {isTSImportEqualsDeclaration} = types',
+    isTSImportType: 'const {isTSImportType} = types',
+    isTSIndexSignature: 'const {isTSIndexSignature} = types',
+    isTSIndexedAccessType: 'const {isTSIndexedAccessType} = types',
+    isTSInferType: 'const {isTSInferType} = types',
+    isTSInstantiationExpression: 'const {isTSInstantiationExpression} = types',
+    isTSInterfaceBody: 'const {isTSInterfaceBody} = types',
+    isTSInterfaceDeclaration: 'const {isTSInterfaceDeclaration} = types',
+    isTSInterfaceHeritage: 'const {isTSInterfaceHeritage} = types',
+    isTSIntersectionType: 'const {isTSIntersectionType} = types',
+    isTSIntrinsicKeyword: 'const {isTSIntrinsicKeyword} = types',
+    isTSLiteralType: 'const {isTSLiteralType} = types',
+    isTSMappedType: 'const {isTSMappedType} = types',
+    isTSMethodSignature: 'const {isTSMethodSignature} = types',
+    isTSModuleBlock: 'const {isTSModuleBlock} = types',
+    isTSModuleDeclaration: 'const {isTSModuleDeclaration} = types',
+    isTSNamedTupleMember: 'const {isTSNamedTupleMember} = types',
+    isTSNamespaceExportDeclaration: 'const {isTSNamespaceExportDeclaration} = types',
+    isTSNeverKeyword: 'const {isTSNeverKeyword} = types',
+    isTSNonNullExpression: 'const {isTSNonNullExpression} = types',
+    isTSNullKeyword: 'const {isTSNullKeyword} = types',
+    isTSNumberKeyword: 'const {isTSNumberKeyword} = types',
+    isTSObjectKeyword: 'const {isTSObjectKeyword} = types',
+    isTSOptionalType: 'const {isTSOptionalType} = types',
+    isTSParameterProperty: 'const {isTSParameterProperty} = types',
+    isTSParenthesizedType: 'const {isTSParenthesizedType} = types',
+    isTSPropertySignature: 'const {isTSPropertySignature} = types',
+    isTSQualifiedName: 'const {isTSQualifiedName} = types',
+    isTSRestType: 'const {isTSRestType} = types',
+    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',
+    isTSTypeAliasDeclaration: 'const {isTSTypeAliasDeclaration} = types',
+    isTSTypeAnnotation: 'const {isTSTypeAnnotation} = types',
+    isTSTypeAssertion: 'const {isTSTypeAssertion} = types',
+    isTSTypeElement: 'const {isTSTypeElement} = types',
+    isTSTypeLiteral: 'const {isTSTypeLiteral} = types',
+    isTSTypeOperator: 'const {isTSTypeOperator} = types',
+    isTSTypeParameter: 'const {isTSTypeParameter} = types',
+    isTSTypeParameterDeclaration: 'const {isTSTypeParameterDeclaration} = types',
+    isTSTypeParameterInstantiation: 'const {isTSTypeParameterInstantiation} = types',
+    isTSTypePredicate: 'const {isTSTypePredicate} = types',
+    isTSTypeQuery: 'const {isTSTypeQuery} = types',
+    isTSTypeReference: 'const {isTSTypeReference} = types',
+    isTSUndefinedKeyword: 'const {isTSUndefinedKeyword} = types',
+    isTSUnionType: 'const {isTSUnionType} = types',
+    isTSUnknownKeyword: 'const {isTSUnknownKeyword} = types',
+    isTSVoidKeyword: 'const {isTSVoidKeyword} = types',
+    isTaggedTemplateExpression: 'const {isTaggedTemplateExpression} = types',
+    isTemplateElement: 'const {isTemplateElement} = types',
+    isTemplateLiteral: 'const {isTemplateLiteral} = types',
+    isTerminatorless: 'const {isTerminatorless} = types',
+    isThisExpression: 'const {isThisExpression} = types',
+    isThisTypeAnnotation: 'const {isThisTypeAnnotation} = types',
+    isThrowStatement: 'const {isThrowStatement} = types',
+    isTopicReference: 'const {isTopicReference} = types',
+    isTryStatement: 'const {isTryStatement} = types',
+    isTupleExpression: 'const {isTupleExpression} = types',
+    isTupleTypeAnnotation: 'const {isTupleTypeAnnotation} = types',
+    isType: 'const {isType} = types',
+    isTypeAlias: 'const {isTypeAlias} = types',
+    isTypeAnnotation: 'const {isTypeAnnotation} = types',
+    isTypeCastExpression: 'const {isTypeCastExpression} = types',
+    isTypeParameter: 'const {isTypeParameter} = types',
+    isTypeParameterDeclaration: 'const {isTypeParameterDeclaration} = types',
+    isTypeParameterInstantiation: 'const {isTypeParameterInstantiation} = types',
+    isTypeScript: 'const {isTypeScript} = types',
+    isTypeofTypeAnnotation: 'const {isTypeofTypeAnnotation} = types',
+    isUnaryExpression: 'const {isUnaryExpression} = types',
+    isUnaryLike: 'const {isUnaryLike} = types',
+    isUnionTypeAnnotation: 'const {isUnionTypeAnnotation} = types',
+    isUpdateExpression: 'const {isUpdateExpression} = types',
+    isUserWhitespacable: 'const {isUserWhitespacable} = types',
+    isV8IntrinsicIdentifier: 'const {isV8IntrinsicIdentifier} = types',
+    isValidES3Identifier: 'const {isValidES3Identifier} = types',
+    isValidIdentifier: 'const {isValidIdentifier} = types',
+    isVar: 'const {isVar} = types',
+    isVariableDeclaration: 'const {isVariableDeclaration} = types',
+    isVariableDeclarator: 'const {isVariableDeclarator} = types',
+    isVariance: 'const {isVariance} = types',
+    isVoidTypeAnnotation: 'const {isVoidTypeAnnotation} = types',
+    isWhile: 'const {isWhile} = types',
+    isWhileStatement: 'const {isWhileStatement} = types',
+    isWithStatement: 'const {isWithStatement} = 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',
+};