typedoc 0.23.24 → 0.23.25

package/dist/lib/converter/symbols.js

@@ -1,8 +1,11 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.convertSymbol = void 0;
-const assert = require("assert");
-const ts = require("typescript");
+const assert_1 = __importDefault(require("assert"));
+const typescript_1 = __importDefault(require("typescript"));
 const models_1 = require("../models");
 const enum_1 = require("../utils/enum");
 const convert_expression_1 = require("./convert-expression");
@@ -12,24 +15,24 @@ const jsdoc_1 = require("./jsdoc");
 const nodes_1 = require("./utils/nodes");
 const reflections_1 = require("./utils/reflections");
 const symbolConverters = {
-    [ts.SymbolFlags.RegularEnum]: convertEnum,
-    [ts.SymbolFlags.ConstEnum]: convertEnum,
-    [ts.SymbolFlags.EnumMember]: convertEnumMember,
-    [ts.SymbolFlags.ValueModule]: convertNamespace,
-    [ts.SymbolFlags.NamespaceModule]: convertNamespace,
-    [ts.SymbolFlags.TypeAlias]: convertTypeAlias,
-    [ts.SymbolFlags.Function]: convertFunctionOrMethod,
-    [ts.SymbolFlags.Method]: convertFunctionOrMethod,
-    [ts.SymbolFlags.Interface]: convertClassOrInterface,
-    [ts.SymbolFlags.Property]: convertProperty,
-    [ts.SymbolFlags.Class]: convertClassOrInterface,
-    [ts.SymbolFlags.Constructor]: convertConstructor,
-    [ts.SymbolFlags.Alias]: convertAlias,
-    [ts.SymbolFlags.BlockScopedVariable]: convertVariable,
-    [ts.SymbolFlags.FunctionScopedVariable]: convertVariable,
-    [ts.SymbolFlags.ExportValue]: convertVariable,
-    [ts.SymbolFlags.GetAccessor]: convertAccessor,
-    [ts.SymbolFlags.SetAccessor]: convertAccessor,
+    [typescript_1.default.SymbolFlags.RegularEnum]: convertEnum,
+    [typescript_1.default.SymbolFlags.ConstEnum]: convertEnum,
+    [typescript_1.default.SymbolFlags.EnumMember]: convertEnumMember,
+    [typescript_1.default.SymbolFlags.ValueModule]: convertNamespace,
+    [typescript_1.default.SymbolFlags.NamespaceModule]: convertNamespace,
+    [typescript_1.default.SymbolFlags.TypeAlias]: convertTypeAlias,
+    [typescript_1.default.SymbolFlags.Function]: convertFunctionOrMethod,
+    [typescript_1.default.SymbolFlags.Method]: convertFunctionOrMethod,
+    [typescript_1.default.SymbolFlags.Interface]: convertClassOrInterface,
+    [typescript_1.default.SymbolFlags.Property]: convertProperty,
+    [typescript_1.default.SymbolFlags.Class]: convertClassOrInterface,
+    [typescript_1.default.SymbolFlags.Constructor]: convertConstructor,
+    [typescript_1.default.SymbolFlags.Alias]: convertAlias,
+    [typescript_1.default.SymbolFlags.BlockScopedVariable]: convertVariable,
+    [typescript_1.default.SymbolFlags.FunctionScopedVariable]: convertVariable,
+    [typescript_1.default.SymbolFlags.ExportValue]: convertVariable,
+    [typescript_1.default.SymbolFlags.GetAccessor]: convertAccessor,
+    [typescript_1.default.SymbolFlags.SetAccessor]: convertAccessor,
 };
 const allConverterFlags = Object.keys(symbolConverters).reduce((v, k) => v | +k, 0);
 // This is kind of a hack, born of resolving references by symbols instead
@@ -37,33 +40,33 @@ const allConverterFlags = Object.keys(symbolConverters).reduce((v, k) => v | +k,
 const conversionOrder = [
     // Do enums before namespaces so that @hidden on a namespace
     // merged with an enum works properly.
-    ts.SymbolFlags.RegularEnum,
-    ts.SymbolFlags.ConstEnum,
-    ts.SymbolFlags.EnumMember,
+    typescript_1.default.SymbolFlags.RegularEnum,
+    typescript_1.default.SymbolFlags.ConstEnum,
+    typescript_1.default.SymbolFlags.EnumMember,
     // Before type alias
-    ts.SymbolFlags.BlockScopedVariable,
-    ts.SymbolFlags.FunctionScopedVariable,
-    ts.SymbolFlags.ExportValue,
-    ts.SymbolFlags.TypeAlias,
-    ts.SymbolFlags.Function,
-    ts.SymbolFlags.Method,
-    ts.SymbolFlags.Interface,
-    ts.SymbolFlags.Property,
-    ts.SymbolFlags.Class,
-    ts.SymbolFlags.Constructor,
-    ts.SymbolFlags.Alias,
-    ts.SymbolFlags.GetAccessor,
-    ts.SymbolFlags.SetAccessor,
-    ts.SymbolFlags.ValueModule,
-    ts.SymbolFlags.NamespaceModule,
+    typescript_1.default.SymbolFlags.BlockScopedVariable,
+    typescript_1.default.SymbolFlags.FunctionScopedVariable,
+    typescript_1.default.SymbolFlags.ExportValue,
+    typescript_1.default.SymbolFlags.TypeAlias,
+    typescript_1.default.SymbolFlags.Function,
+    typescript_1.default.SymbolFlags.Method,
+    typescript_1.default.SymbolFlags.Interface,
+    typescript_1.default.SymbolFlags.Property,
+    typescript_1.default.SymbolFlags.Class,
+    typescript_1.default.SymbolFlags.Constructor,
+    typescript_1.default.SymbolFlags.Alias,
+    typescript_1.default.SymbolFlags.GetAccessor,
+    typescript_1.default.SymbolFlags.SetAccessor,
+    typescript_1.default.SymbolFlags.ValueModule,
+    typescript_1.default.SymbolFlags.NamespaceModule,
 ];
 // Sanity check, if this fails a dev messed up.
 for (const key of Object.keys(symbolConverters)) {
     if (!Number.isInteger(Math.log2(+key))) {
-        throw new Error(`Symbol converter for key ${ts.SymbolFlags[+key]} does not specify a valid flag value.`);
+        throw new Error(`Symbol converter for key ${typescript_1.default.SymbolFlags[+key]} does not specify a valid flag value.`);
     }
     if (!conversionOrder.includes(+key)) {
-        throw new Error(`Symbol converter for key ${ts.SymbolFlags[+key]} is not specified in conversionOrder`);
+        throw new Error(`Symbol converter for key ${typescript_1.default.SymbolFlags[+key]} is not specified in conversionOrder`);
     }
 }
 if (conversionOrder.reduce((a, b) => a | b, 0) !== allConverterFlags) {
@@ -81,44 +84,44 @@ function convertSymbol(context, symbol, exportSymbol) {
         createAlias(previous, context, symbol, exportSymbol);
         return;
     }
-    let flags = (0, enum_1.removeFlag)(symbol.flags, ts.SymbolFlags.Transient |
-        ts.SymbolFlags.Assignment |
-        ts.SymbolFlags.Optional |
-        ts.SymbolFlags.Prototype);
+    let flags = (0, enum_1.removeFlag)(symbol.flags, typescript_1.default.SymbolFlags.Transient |
+        typescript_1.default.SymbolFlags.Assignment |
+        typescript_1.default.SymbolFlags.Optional |
+        typescript_1.default.SymbolFlags.Prototype);
     // Declaration merging - the only type (excluding enum/enum, ns/ns, etc)
     // that TD supports is merging a class and interface. All others are
     // represented as multiple reflections
-    if ((0, enum_1.hasAllFlags)(symbol.flags, ts.SymbolFlags.Class)) {
-        flags = (0, enum_1.removeFlag)(flags, ts.SymbolFlags.Interface | ts.SymbolFlags.Function);
+    if ((0, enum_1.hasAllFlags)(symbol.flags, typescript_1.default.SymbolFlags.Class)) {
+        flags = (0, enum_1.removeFlag)(flags, typescript_1.default.SymbolFlags.Interface | typescript_1.default.SymbolFlags.Function);
     }
     // Kind of declaration merging... we treat this as a property with get/set signatures.
-    if ((0, enum_1.hasAllFlags)(symbol.flags, ts.SymbolFlags.GetAccessor)) {
-        flags = (0, enum_1.removeFlag)(flags, ts.SymbolFlags.SetAccessor);
+    if ((0, enum_1.hasAllFlags)(symbol.flags, typescript_1.default.SymbolFlags.GetAccessor)) {
+        flags = (0, enum_1.removeFlag)(flags, typescript_1.default.SymbolFlags.SetAccessor);
     }
-    if ((0, enum_1.hasAllFlags)(symbol.flags, ts.SymbolFlags.NamespaceModule)) {
+    if ((0, enum_1.hasAllFlags)(symbol.flags, typescript_1.default.SymbolFlags.NamespaceModule)) {
         // This might be here if a namespace is declared several times.
-        flags = (0, enum_1.removeFlag)(flags, ts.SymbolFlags.ValueModule);
+        flags = (0, enum_1.removeFlag)(flags, typescript_1.default.SymbolFlags.ValueModule);
     }
-    if ((0, enum_1.hasAnyFlag)(symbol.flags, ts.SymbolFlags.Method |
-        ts.SymbolFlags.Interface |
-        ts.SymbolFlags.Class |
-        ts.SymbolFlags.Variable)) {
+    if ((0, enum_1.hasAnyFlag)(symbol.flags, typescript_1.default.SymbolFlags.Method |
+        typescript_1.default.SymbolFlags.Interface |
+        typescript_1.default.SymbolFlags.Class |
+        typescript_1.default.SymbolFlags.Variable)) {
         // This happens when someone declares an object with methods:
         // { methodProperty() {} }
-        flags = (0, enum_1.removeFlag)(flags, ts.SymbolFlags.Property);
+        flags = (0, enum_1.removeFlag)(flags, typescript_1.default.SymbolFlags.Property);
     }
     // A default exported function with no associated variable is a property, but
     // we should really convert it as a variable for documentation purposes
     // export default () => {}
     // export default 123
-    if (flags === ts.SymbolFlags.Property &&
+    if (flags === typescript_1.default.SymbolFlags.Property &&
         symbol.name === "default" &&
         context.scope.kindOf(models_1.ReflectionKind.Module | models_1.ReflectionKind.Project)) {
-        flags = ts.SymbolFlags.BlockScopedVariable;
+        flags = typescript_1.default.SymbolFlags.BlockScopedVariable;
     }
     for (const flag of (0, enum_1.getEnumFlags)(flags ^ allConverterFlags)) {
         if (!(flag & allConverterFlags)) {
-            context.logger.verbose(`Missing converter for symbol: ${symbol.name} with flag ${ts.SymbolFlags[flag]}`);
+            context.logger.verbose(`Missing converter for symbol: ${symbol.name} with flag ${typescript_1.default.SymbolFlags[flag]}`);
         }
     }
     // Note: This method does not allow skipping earlier converters.
@@ -140,13 +143,13 @@ function convertSymbols(context, symbols) {
 }
 function convertEnum(context, symbol, exportSymbol) {
     const reflection = context.createDeclarationReflection(models_1.ReflectionKind.Enum, symbol, exportSymbol);
-    if (symbol.flags & ts.SymbolFlags.ConstEnum) {
+    if (symbol.flags & typescript_1.default.SymbolFlags.ConstEnum) {
         reflection.setFlag(models_1.ReflectionFlag.Const);
     }
     context.finalizeDeclarationReflection(reflection);
     convertSymbols(context.withScope(reflection), context.checker
         .getExportsOfModule(symbol)
-        .filter((s) => s.flags & ts.SymbolFlags.EnumMember));
+        .filter((s) => s.flags & typescript_1.default.SymbolFlags.EnumMember));
 }
 function convertEnumMember(context, symbol, exportSymbol) {
     const reflection = context.createDeclarationReflection(models_1.ReflectionKind.EnumMember, symbol, exportSymbol);
@@ -162,14 +165,14 @@ function convertEnumMember(context, symbol, exportSymbol) {
     context.finalizeDeclarationReflection(reflection);
 }
 function convertNamespace(context, symbol, exportSymbol) {
-    let exportFlags = ts.SymbolFlags.ModuleMember;
+    let exportFlags = typescript_1.default.SymbolFlags.ModuleMember;
     // This can happen in JS land where "class" functions get tagged as a namespace too
     if (symbol
         .getDeclarations()
-        ?.some((d) => ts.isModuleDeclaration(d) || ts.isSourceFile(d)) !==
+        ?.some((d) => typescript_1.default.isModuleDeclaration(d) || typescript_1.default.isSourceFile(d)) !==
         true) {
-        exportFlags = ts.SymbolFlags.ClassMember;
-        if ((0, enum_1.hasAnyFlag)(symbol.flags, ts.SymbolFlags.Class)) {
+        exportFlags = typescript_1.default.SymbolFlags.ClassMember;
+        if ((0, enum_1.hasAnyFlag)(symbol.flags, typescript_1.default.SymbolFlags.Class)) {
             return;
         }
     }
@@ -182,12 +185,12 @@ function convertNamespace(context, symbol, exportSymbol) {
 function convertTypeAlias(context, symbol, exportSymbol) {
     const declaration = symbol
         ?.getDeclarations()
-        ?.find((d) => ts.isTypeAliasDeclaration(d) ||
-        ts.isJSDocTypedefTag(d) ||
-        ts.isJSDocCallbackTag(d) ||
-        ts.isJSDocEnumTag(d));
-    assert(declaration);
-    if (ts.isTypeAliasDeclaration(declaration)) {
+        ?.find((d) => typescript_1.default.isTypeAliasDeclaration(d) ||
+        typescript_1.default.isJSDocTypedefTag(d) ||
+        typescript_1.default.isJSDocCallbackTag(d) ||
+        typescript_1.default.isJSDocEnumTag(d));
+    (0, assert_1.default)(declaration);
+    if (typescript_1.default.isTypeAliasDeclaration(declaration)) {
         const reflection = context.createDeclarationReflection(models_1.ReflectionKind.TypeAlias, symbol, exportSymbol);
         reflection.type = context.converter.convertType(context.withScope(reflection), declaration.type);
         context.finalizeDeclarationReflection(reflection);
@@ -195,8 +198,8 @@ function convertTypeAlias(context, symbol, exportSymbol) {
         // from the parent comment. Ugly, but works for now. Should be cleaned up eventually.
         reflection.typeParameters = declaration.typeParameters?.map((param) => (0, signature_1.createTypeParamReflection)(param, context.withScope(reflection)));
     }
-    else if (ts.isJSDocTypedefTag(declaration) ||
-        ts.isJSDocEnumTag(declaration)) {
+    else if (typescript_1.default.isJSDocTypedefTag(declaration) ||
+        typescript_1.default.isJSDocEnumTag(declaration)) {
         (0, jsdoc_1.convertJsDocAlias)(context, symbol, declaration, exportSymbol);
     }
     else {
@@ -207,22 +210,22 @@ function convertFunctionOrMethod(context, symbol, exportSymbol) {
     // Can't just check method flag because this might be called for properties as well
     // This will *NOT* be called for variables that look like functions, they need a special case.
     const isMethod = !!(symbol.flags &
-        (ts.SymbolFlags.Property | ts.SymbolFlags.Method));
-    const declarations = symbol.getDeclarations()?.filter(ts.isFunctionLike) ?? [];
+        (typescript_1.default.SymbolFlags.Property | typescript_1.default.SymbolFlags.Method));
+    const declarations = symbol.getDeclarations()?.filter(typescript_1.default.isFunctionLike) ?? [];
     // Don't do anything if we inherited this method and it is private.
     if (isMethod &&
         isInherited(context, symbol) &&
         declarations.length > 0 &&
-        (0, enum_1.hasAllFlags)(ts.getCombinedModifierFlags(declarations[0]), ts.ModifierFlags.Private)) {
+        (0, enum_1.hasAllFlags)(typescript_1.default.getCombinedModifierFlags(declarations[0]), typescript_1.default.ModifierFlags.Private)) {
         return;
     }
     const parentSymbol = context.project.getSymbolFromReflection(context.scope);
     const locationDeclaration = parentSymbol
         ?.getDeclarations()
-        ?.find((d) => ts.isClassDeclaration(d) || ts.isInterfaceDeclaration(d)) ??
+        ?.find((d) => typescript_1.default.isClassDeclaration(d) || typescript_1.default.isInterfaceDeclaration(d)) ??
         parentSymbol?.getDeclarations()?.[0]?.getSourceFile() ??
         symbol.getDeclarations()?.[0]?.getSourceFile();
-    assert(locationDeclaration, "Missing declaration context");
+    (0, assert_1.default)(locationDeclaration, "Missing declaration context");
     const type = context.checker.getTypeOfSymbolAtLocation(symbol, locationDeclaration);
     // Need to get the non nullable type because interface methods might be declared
     // with a question token. See GH1490.
@@ -247,26 +250,26 @@ function convertFunctionOrMethod(context, symbol, exportSymbol) {
 // getDeclaredTypeOfSymbol gets the INSTANCE type
 // getTypeOfSymbolAtLocation gets the STATIC type
 function convertClassOrInterface(context, symbol, exportSymbol) {
-    const reflection = context.createDeclarationReflection(ts.SymbolFlags.Class & symbol.flags
+    const reflection = context.createDeclarationReflection(typescript_1.default.SymbolFlags.Class & symbol.flags
         ? models_1.ReflectionKind.Class
         : models_1.ReflectionKind.Interface, symbol, exportSymbol, void 0);
     const classDeclaration = symbol
         .getDeclarations()
-        ?.find((d) => ts.isClassDeclaration(d) || ts.isFunctionDeclaration(d));
+        ?.find((d) => typescript_1.default.isClassDeclaration(d) || typescript_1.default.isFunctionDeclaration(d));
     if (classDeclaration)
         setModifiers(symbol, classDeclaration, reflection);
     const reflectionContext = context.withScope(reflection);
     const instanceType = context.checker.getDeclaredTypeOfSymbol(symbol);
-    assert(instanceType.isClassOrInterface());
+    (0, assert_1.default)(instanceType.isClassOrInterface());
     // We might do some inheritance - do this first so that it's set when converting properties
     const declarations = symbol
         .getDeclarations()
-        ?.filter((d) => ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) ?? [];
-    const extendedTypes = (0, nodes_1.getHeritageTypes)(declarations, ts.SyntaxKind.ExtendsKeyword).map((t) => context.converter.convertType(reflectionContext, t));
+        ?.filter((d) => typescript_1.default.isInterfaceDeclaration(d) || typescript_1.default.isClassDeclaration(d)) ?? [];
+    const extendedTypes = (0, nodes_1.getHeritageTypes)(declarations, typescript_1.default.SyntaxKind.ExtendsKeyword).map((t) => context.converter.convertType(reflectionContext, t));
     if (extendedTypes.length) {
         reflection.extendedTypes = extendedTypes;
     }
-    const implementedTypes = (0, nodes_1.getHeritageTypes)(declarations, ts.SyntaxKind.ImplementsKeyword).map((t) => context.converter.convertType(reflectionContext, t));
+    const implementedTypes = (0, nodes_1.getHeritageTypes)(declarations, typescript_1.default.SyntaxKind.ImplementsKeyword).map((t) => context.converter.convertType(reflectionContext, t));
     if (implementedTypes.length) {
         reflection.implementedTypes = implementedTypes;
     }
@@ -278,7 +281,7 @@ function convertClassOrInterface(context, symbol, exportSymbol) {
         for (const prop of context.checker.getPropertiesOfType(staticType)) {
             // Don't convert namespace members, or the prototype here.
             if (prop.flags &
-                (ts.SymbolFlags.ModuleMember | ts.SymbolFlags.Prototype))
+                (typescript_1.default.SymbolFlags.ModuleMember | typescript_1.default.SymbolFlags.Prototype))
                 continue;
             convertSymbol(reflectionContext, prop);
         }
@@ -301,14 +304,14 @@ function convertClassOrInterface(context, symbol, exportSymbol) {
     if (instanceType.typeParameters) {
         reflection.typeParameters = instanceType.typeParameters.map((param) => {
             const declaration = param.symbol?.declarations?.[0];
-            assert(declaration && ts.isTypeParameterDeclaration(declaration));
+            (0, assert_1.default)(declaration && typescript_1.default.isTypeParameterDeclaration(declaration));
             return (0, signature_1.createTypeParamReflection)(declaration, reflectionContext);
         });
     }
     // Interfaces might also have call signatures
     // Classes might too, because of declaration merging
     context.checker
-        .getSignaturesOfType(instanceType, ts.SignatureKind.Call)
+        .getSignaturesOfType(instanceType, typescript_1.default.SignatureKind.Call)
         .forEach((sig) => (0, signature_1.createSignature)(reflectionContext, models_1.ReflectionKind.CallSignature, sig));
     // We also might have constructor signatures
     // This is potentially a problem with classes having multiple "constructor" members...
@@ -322,22 +325,22 @@ function convertProperty(context, symbol, exportSymbol) {
     // Don't do anything if we inherited this property and it is private.
     if (isInherited(context, symbol) &&
         declarations.length > 0 &&
-        (0, enum_1.hasAllFlags)(ts.getCombinedModifierFlags(declarations[0]), ts.ModifierFlags.Private)) {
+        (0, enum_1.hasAllFlags)(typescript_1.default.getCombinedModifierFlags(declarations[0]), typescript_1.default.ModifierFlags.Private)) {
         return;
     }
     // Special case: We pretend properties are methods if they look like methods.
     // This happens with mixins / weird inheritance.
     if (declarations.length &&
-        declarations.every((decl) => ts.isMethodSignature(decl) || ts.isMethodDeclaration(decl))) {
+        declarations.every((decl) => typescript_1.default.isMethodSignature(decl) || typescript_1.default.isMethodDeclaration(decl))) {
         return convertFunctionOrMethod(context, symbol, exportSymbol);
     }
     if (declarations.length === 1) {
         const declaration = declarations[0];
         // Special case: "arrow methods" should be treated as methods.
-        if (ts.isPropertyDeclaration(declaration) &&
+        if (typescript_1.default.isPropertyDeclaration(declaration) &&
             !declaration.type &&
             declaration.initializer &&
-            ts.isArrowFunction(declaration.initializer)) {
+            typescript_1.default.isArrowFunction(declaration.initializer)) {
             return convertArrowAsMethod(context, symbol, declaration.initializer, exportSymbol);
         }
     }
@@ -348,11 +351,11 @@ function convertProperty(context, symbol, exportSymbol) {
     const declaration = symbol.getDeclarations()?.[0];
     let parameterType;
     if (declaration &&
-        (ts.isPropertyDeclaration(declaration) ||
-            ts.isPropertySignature(declaration) ||
-            ts.isParameter(declaration) ||
-            ts.isPropertyAccessExpression(declaration))) {
-        if (!ts.isPropertyAccessExpression(declaration)) {
+        (typescript_1.default.isPropertyDeclaration(declaration) ||
+            typescript_1.default.isPropertySignature(declaration) ||
+            typescript_1.default.isParameter(declaration) ||
+            typescript_1.default.isPropertyAccessExpression(declaration))) {
+        if (!typescript_1.default.isPropertyAccessExpression(declaration)) {
             parameterType = declaration.type;
         }
         setModifiers(symbol, declaration, reflection);
@@ -371,17 +374,17 @@ function convertArrowAsMethod(context, symbol, arrow, exportSymbol) {
     context.finalizeDeclarationReflection(reflection);
     const rc = context.withScope(reflection);
     const signature = context.checker.getSignatureFromDeclaration(arrow);
-    assert(signature);
+    (0, assert_1.default)(signature);
     (0, signature_1.createSignature)(rc, models_1.ReflectionKind.CallSignature, signature, arrow);
 }
 function convertConstructor(context, symbol) {
     const reflection = context.createDeclarationReflection(models_1.ReflectionKind.Constructor, symbol, void 0, "constructor");
     context.finalizeDeclarationReflection(reflection);
     const reflectionContext = context.withScope(reflection);
-    const declarations = symbol.getDeclarations()?.filter(ts.isConstructorDeclaration) ?? [];
+    const declarations = symbol.getDeclarations()?.filter(typescript_1.default.isConstructorDeclaration) ?? [];
     const signatures = declarations.map((decl) => {
         const sig = context.checker.getSignatureFromDeclaration(decl);
-        assert(sig);
+        (0, assert_1.default)(sig);
         return sig;
     });
     for (const sig of signatures) {
@@ -392,7 +395,7 @@ function convertConstructSignatures(context, symbol) {
     const type = context.checker.getDeclaredTypeOfSymbol(symbol);
     // These get added as a "constructor" member of this interface. This is a problem... but nobody
     // has complained yet. We really ought to have a constructSignatures property on the reflection instead.
-    const constructSignatures = context.checker.getSignaturesOfType(type, ts.SignatureKind.Construct);
+    const constructSignatures = context.checker.getSignaturesOfType(type, typescript_1.default.SignatureKind.Construct);
     if (constructSignatures.length) {
         const constructMember = new models_1.DeclarationReflection("constructor", models_1.ReflectionKind.Constructor, context.scope);
         context.postReflectionCreation(constructMember, symbol, void 0);
@@ -419,7 +422,7 @@ function createAlias(target, context, symbol, exportSymbol) {
 }
 function convertVariable(context, symbol, exportSymbol) {
     const declaration = symbol.getDeclarations()?.[0];
-    assert(declaration);
+    (0, assert_1.default)(declaration);
     const type = context.checker.getTypeOfSymbolAtLocation(symbol, declaration);
     if (isEnumLike(context.checker, type, declaration) &&
         symbol.getJsDocTags().some((tag) => tag.name === "enum")) {
@@ -430,7 +433,7 @@ function convertVariable(context, symbol, exportSymbol) {
     }
     const reflection = context.createDeclarationReflection(models_1.ReflectionKind.Variable, symbol, exportSymbol);
     let typeNode;
-    if (ts.isVariableDeclaration(declaration)) {
+    if (typescript_1.default.isVariableDeclaration(declaration)) {
         // Otherwise we might have destructuring
         typeNode = declaration.type;
     }
@@ -438,10 +441,10 @@ function convertVariable(context, symbol, exportSymbol) {
     setModifiers(symbol, declaration, reflection);
     reflection.defaultValue = (0, convert_expression_1.convertDefaultValue)(declaration);
     context.finalizeDeclarationReflection(reflection);
-    return ts.SymbolFlags.Property;
+    return typescript_1.default.SymbolFlags.Property;
 }
 function isEnumLike(checker, type, location) {
-    if (!(0, enum_1.hasAllFlags)(type.flags, ts.TypeFlags.Object)) {
+    if (!(0, enum_1.hasAllFlags)(type.flags, typescript_1.default.TypeFlags.Object)) {
         return false;
     }
     return type.getProperties().every((prop) => {
@@ -450,7 +453,7 @@ function isEnumLike(checker, type, location) {
     });
 }
 function isValidEnumProperty(type) {
-    return (0, enum_1.hasAnyFlag)(type.flags, ts.TypeFlags.NumberLike | ts.TypeFlags.StringLike);
+    return (0, enum_1.hasAnyFlag)(type.flags, typescript_1.default.TypeFlags.NumberLike | typescript_1.default.TypeFlags.StringLike);
 }
 function convertVariableAsEnum(context, symbol, exportSymbol) {
     const reflection = context.createDeclarationReflection(models_1.ReflectionKind.Enum, symbol, exportSymbol);
@@ -465,12 +468,12 @@ function convertVariableAsEnum(context, symbol, exportSymbol) {
         rc.finalizeDeclarationReflection(reflection);
     }
     // Skip converting the type alias, if there is one
-    return ts.SymbolFlags.TypeAlias;
+    return typescript_1.default.SymbolFlags.TypeAlias;
 }
 function convertVariableAsFunction(context, symbol, exportSymbol) {
     const declaration = symbol
         .getDeclarations()
-        ?.find(ts.isVariableDeclaration);
+        ?.find(typescript_1.default.isVariableDeclaration);
     const accessDeclaration = declaration ?? symbol.valueDeclaration;
     const type = accessDeclaration
         ? context.checker.getTypeOfSymbolAtLocation(symbol, accessDeclaration)
@@ -484,7 +487,7 @@ function convertVariableAsFunction(context, symbol, exportSymbol) {
     for (const signature of type.getCallSignatures()) {
         (0, signature_1.createSignature)(reflectionContext, models_1.ReflectionKind.CallSignature, signature);
     }
-    return ts.SymbolFlags.Property;
+    return typescript_1.default.SymbolFlags.Property;
 }
 function convertAccessor(context, symbol, exportSymbol) {
     const reflection = context.createDeclarationReflection(models_1.ReflectionKind.Accessor, symbol, exportSymbol);
@@ -494,14 +497,14 @@ function convertAccessor(context, symbol, exportSymbol) {
         setModifiers(symbol, declaration, reflection);
     }
     context.finalizeDeclarationReflection(reflection);
-    const getDeclaration = symbol.getDeclarations()?.find(ts.isGetAccessor);
+    const getDeclaration = symbol.getDeclarations()?.find(typescript_1.default.isGetAccessor);
     if (getDeclaration) {
         const signature = context.checker.getSignatureFromDeclaration(getDeclaration);
         if (signature) {
             (0, signature_1.createSignature)(rc, models_1.ReflectionKind.GetSignature, signature, getDeclaration);
         }
     }
-    const setDeclaration = symbol.getDeclarations()?.find(ts.isSetAccessor);
+    const setDeclaration = symbol.getDeclarations()?.find(typescript_1.default.isSetAccessor);
     if (setDeclaration) {
         const signature = context.checker.getSignatureFromDeclaration(setDeclaration);
         if (signature) {
@@ -511,10 +514,10 @@ function convertAccessor(context, symbol, exportSymbol) {
 }
 function isInherited(context, symbol) {
     const parentSymbol = context.project.getSymbolFromReflection(context.scope);
-    assert(parentSymbol, `No parent symbol found for ${symbol.name} in ${context.scope.name}`);
+    (0, assert_1.default)(parentSymbol, `No parent symbol found for ${symbol.name} in ${context.scope.name}`);
     const parents = parentSymbol.declarations?.slice() || [];
-    const constructorDecls = parents.flatMap((parent) => ts.isClassDeclaration(parent)
-        ? parent.members.filter(ts.isConstructorDeclaration)
+    const constructorDecls = parents.flatMap((parent) => typescript_1.default.isClassDeclaration(parent)
+        ? parent.members.filter(typescript_1.default.isConstructorDeclaration)
         : []);
     parents.push(...constructorDecls);
     return (parents.some((d) => symbol.getDeclarations()?.some((d2) => d2.parent === d)) === false);
@@ -523,30 +526,30 @@ function setModifiers(symbol, declaration, reflection) {
     if (!declaration) {
         return;
     }
-    const modifiers = ts.getCombinedModifierFlags(declaration);
-    if (ts.isMethodDeclaration(declaration) ||
-        ts.isPropertyDeclaration(declaration) ||
-        ts.isAccessor(declaration)) {
-        if (ts.isPrivateIdentifier(declaration.name)) {
+    const modifiers = typescript_1.default.getCombinedModifierFlags(declaration);
+    if (typescript_1.default.isMethodDeclaration(declaration) ||
+        typescript_1.default.isPropertyDeclaration(declaration) ||
+        typescript_1.default.isAccessor(declaration)) {
+        if (typescript_1.default.isPrivateIdentifier(declaration.name)) {
             reflection.setFlag(models_1.ReflectionFlag.Private);
         }
     }
-    if ((0, enum_1.hasAllFlags)(modifiers, ts.ModifierFlags.Private)) {
+    if ((0, enum_1.hasAllFlags)(modifiers, typescript_1.default.ModifierFlags.Private)) {
         reflection.setFlag(models_1.ReflectionFlag.Private);
     }
-    if ((0, enum_1.hasAllFlags)(modifiers, ts.ModifierFlags.Protected)) {
+    if ((0, enum_1.hasAllFlags)(modifiers, typescript_1.default.ModifierFlags.Protected)) {
         reflection.setFlag(models_1.ReflectionFlag.Protected);
     }
-    if ((0, enum_1.hasAllFlags)(modifiers, ts.ModifierFlags.Public)) {
+    if ((0, enum_1.hasAllFlags)(modifiers, typescript_1.default.ModifierFlags.Public)) {
         reflection.setFlag(models_1.ReflectionFlag.Public);
     }
-    reflection.setFlag(models_1.ReflectionFlag.Optional, (0, enum_1.hasAllFlags)(symbol.flags, ts.SymbolFlags.Optional));
-    reflection.setFlag(models_1.ReflectionFlag.Readonly, (0, enum_1.hasAllFlags)(symbol.checkFlags ?? 0, ts.CheckFlags.Readonly) ||
-        (0, enum_1.hasAllFlags)(modifiers, ts.ModifierFlags.Readonly));
-    reflection.setFlag(models_1.ReflectionFlag.Abstract, (0, enum_1.hasAllFlags)(modifiers, ts.ModifierFlags.Abstract));
+    reflection.setFlag(models_1.ReflectionFlag.Optional, (0, enum_1.hasAllFlags)(symbol.flags, typescript_1.default.SymbolFlags.Optional));
+    reflection.setFlag(models_1.ReflectionFlag.Readonly, (0, enum_1.hasAllFlags)(symbol.checkFlags ?? 0, typescript_1.default.CheckFlags.Readonly) ||
+        (0, enum_1.hasAllFlags)(modifiers, typescript_1.default.ModifierFlags.Readonly));
+    reflection.setFlag(models_1.ReflectionFlag.Abstract, (0, enum_1.hasAllFlags)(modifiers, typescript_1.default.ModifierFlags.Abstract));
     if (reflection.kindOf(models_1.ReflectionKind.Variable) &&
-        (0, enum_1.hasAllFlags)(symbol.flags, ts.SymbolFlags.BlockScopedVariable)) {
-        reflection.setFlag(models_1.ReflectionFlag.Const, (0, enum_1.hasAllFlags)(declaration.parent.flags, ts.NodeFlags.Const));
+        (0, enum_1.hasAllFlags)(symbol.flags, typescript_1.default.SymbolFlags.BlockScopedVariable)) {
+        reflection.setFlag(models_1.ReflectionFlag.Const, (0, enum_1.hasAllFlags)(declaration.parent.flags, typescript_1.default.NodeFlags.Const));
     }
     // ReflectionFlag.Static happens when constructing the reflection.
     // We don't have sufficient information here to determine if it ought to be static.

package/dist/lib/converter/types.d.ts

@@ -1,4 +1,4 @@
-import * as ts from "typescript";
+import ts from "typescript";
 import { SomeType } from "../models";
 import type { Context } from "./context";
 export interface TypeConverter<TNode extends ts.TypeNode = ts.TypeNode, TType extends ts.Type = ts.Type> {