typedoc 0.26.11 → 0.27.0-beta.0

package/dist/lib/converter/symbols.js

@@ -1,38 +1,32 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertSymbol = convertSymbol;
-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");
-const index_signature_1 = require("./factories/index-signature");
-const signature_1 = require("./factories/signature");
-const jsdoc_1 = require("./jsdoc");
-const nodes_1 = require("./utils/nodes");
-const reflections_1 = require("./utils/reflections");
+import assert from "assert";
+import ts from "typescript";
+import { DeclarationReflection, IntrinsicType, LiteralType, ReferenceReflection, ReflectionFlag, ReflectionKind, } from "../models/index.js";
+import { getEnumFlags, hasAllFlags, hasAnyFlag, removeFlag, } from "../utils/enum.js";
+import { convertDefaultValue } from "./convert-expression.js";
+import { convertIndexSignatures } from "./factories/index-signature.js";
+import { createConstructSignatureWithType, createSignature, createTypeParamReflection, } from "./factories/signature.js";
+import { convertJsDocAlias, convertJsDocCallback } from "./jsdoc.js";
+import { getHeritageTypes } from "./utils/nodes.js";
+import { removeUndefined } from "./utils/reflections.js";
 const symbolConverters = {
-    [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,
+    [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,
 };
 const allConverterFlags = Object.keys(symbolConverters).reduce((v, k) => v | +k, 0);
 // This is kind of a hack, born of resolving references by symbols instead
@@ -40,39 +34,39 @@ 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.
-    typescript_1.default.SymbolFlags.RegularEnum,
-    typescript_1.default.SymbolFlags.ConstEnum,
-    typescript_1.default.SymbolFlags.EnumMember,
+    ts.SymbolFlags.RegularEnum,
+    ts.SymbolFlags.ConstEnum,
+    ts.SymbolFlags.EnumMember,
     // Before type alias
-    typescript_1.default.SymbolFlags.BlockScopedVariable,
-    typescript_1.default.SymbolFlags.FunctionScopedVariable,
-    typescript_1.default.SymbolFlags.ExportValue,
-    typescript_1.default.SymbolFlags.Function, // Before NamespaceModule
-    typescript_1.default.SymbolFlags.TypeAlias,
-    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,
+    ts.SymbolFlags.BlockScopedVariable,
+    ts.SymbolFlags.FunctionScopedVariable,
+    ts.SymbolFlags.ExportValue,
+    ts.SymbolFlags.Function, // Before NamespaceModule
+    ts.SymbolFlags.TypeAlias,
+    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,
 ];
 // 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 ${typescript_1.default.SymbolFlags[+key]} does not specify a valid flag value.`);
+        throw new Error(`Symbol converter for key ${ts.SymbolFlags[+key]} does not specify a valid flag value.`);
     }
     if (!conversionOrder.includes(+key)) {
-        throw new Error(`Symbol converter for key ${typescript_1.default.SymbolFlags[+key]} is not specified in conversionOrder`);
+        throw new Error(`Symbol converter for key ${ts.SymbolFlags[+key]} is not specified in conversionOrder`);
     }
 }
 if (conversionOrder.reduce((a, b) => a | b, 0) !== allConverterFlags) {
     throw new Error("conversionOrder contains a symbol flag that converters do not.");
 }
-function convertSymbol(context, symbol, exportSymbol) {
+export function convertSymbol(context, symbol, exportSymbol) {
     if (context.shouldIgnore(symbol)) {
         return;
     }
@@ -80,42 +74,42 @@ function convertSymbol(context, symbol, exportSymbol) {
     // but aren't aliased symbols because `export *` was used.
     const previous = context.project.getReflectionFromSymbol(symbol);
     if (previous &&
-        previous.parent?.kindOf(models_1.ReflectionKind.SomeModule | models_1.ReflectionKind.Project)) {
+        previous.parent?.kindOf(ReflectionKind.SomeModule | ReflectionKind.Project)) {
         createAlias(previous, context, symbol, exportSymbol);
         return;
     }
-    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);
+    let flags = removeFlag(symbol.flags, ts.SymbolFlags.Transient |
+        ts.SymbolFlags.Assignment |
+        ts.SymbolFlags.Optional |
+        ts.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, typescript_1.default.SymbolFlags.Class)) {
-        flags = (0, enum_1.removeFlag)(flags, typescript_1.default.SymbolFlags.Interface | typescript_1.default.SymbolFlags.Function);
+    if (hasAllFlags(symbol.flags, ts.SymbolFlags.Class)) {
+        flags = removeFlag(flags, ts.SymbolFlags.Interface | ts.SymbolFlags.Function);
     }
     // Kind of declaration merging... we treat this as a property with get/set signatures.
-    if ((0, enum_1.hasAllFlags)(symbol.flags, typescript_1.default.SymbolFlags.GetAccessor)) {
-        flags = (0, enum_1.removeFlag)(flags, typescript_1.default.SymbolFlags.SetAccessor);
+    if (hasAllFlags(symbol.flags, ts.SymbolFlags.GetAccessor)) {
+        flags = removeFlag(flags, ts.SymbolFlags.SetAccessor);
     }
-    if ((0, enum_1.hasAllFlags)(symbol.flags, typescript_1.default.SymbolFlags.NamespaceModule)) {
+    if (hasAllFlags(symbol.flags, ts.SymbolFlags.NamespaceModule)) {
         // This might be here if a namespace is declared several times.
         // Or if it's a namespace-like thing defined on a function
         // In the function case, it's important to remove ValueModule so that
         // if we convert the children as properties of the function rather than as
         // a separate namespace, we skip creating the namespace.
-        flags = (0, enum_1.removeFlag)(flags, typescript_1.default.SymbolFlags.ValueModule);
+        flags = removeFlag(flags, ts.SymbolFlags.ValueModule);
     }
-    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)) {
+    if (hasAnyFlag(symbol.flags, ts.SymbolFlags.Method |
+        ts.SymbolFlags.Interface |
+        ts.SymbolFlags.Class |
+        ts.SymbolFlags.Variable)) {
         // This happens when someone declares an object with methods:
         // { methodProperty() {} }
-        flags = (0, enum_1.removeFlag)(flags, typescript_1.default.SymbolFlags.Property);
+        flags = removeFlag(flags, ts.SymbolFlags.Property);
     }
-    for (const flag of (0, enum_1.getEnumFlags)(flags & ~allConverterFlags)) {
-        context.logger.verbose(`Missing converter for symbol: ${symbol.name} with flag ${typescript_1.default.SymbolFlags[flag]}`);
+    for (const flag of getEnumFlags(flags & ~allConverterFlags)) {
+        context.logger.verbose(`Missing converter for symbol: ${symbol.name} with flag ${ts.SymbolFlags[flag]}`);
     }
     // Note: This method does not allow skipping earlier converters.
     // For now, this is fine... might not be flexible enough in the future.
@@ -134,48 +128,48 @@ function convertSymbols(context, symbols) {
     }
 }
 function convertEnum(context, symbol, exportSymbol) {
-    const reflection = context.createDeclarationReflection(models_1.ReflectionKind.Enum, symbol, exportSymbol);
-    if (symbol.flags & typescript_1.default.SymbolFlags.ConstEnum) {
-        reflection.setFlag(models_1.ReflectionFlag.Const);
+    const reflection = context.createDeclarationReflection(ReflectionKind.Enum, symbol, exportSymbol);
+    if (symbol.flags & ts.SymbolFlags.ConstEnum) {
+        reflection.setFlag(ReflectionFlag.Const);
     }
     context.finalizeDeclarationReflection(reflection);
     convertSymbols(context.withScope(reflection), context.checker
         .getExportsOfModule(symbol)
-        .filter((s) => s.flags & typescript_1.default.SymbolFlags.EnumMember));
+        .filter((s) => s.flags & ts.SymbolFlags.EnumMember));
 }
 function convertEnumMember(context, symbol, exportSymbol) {
-    const reflection = context.createDeclarationReflection(models_1.ReflectionKind.EnumMember, symbol, exportSymbol);
+    const reflection = context.createDeclarationReflection(ReflectionKind.EnumMember, symbol, exportSymbol);
     const defaultValue = context.checker.getConstantValue(symbol.getDeclarations()[0]);
     if (defaultValue !== undefined) {
-        reflection.type = new models_1.LiteralType(defaultValue);
+        reflection.type = new LiteralType(defaultValue);
     }
     else {
         // We know this has to be a number, because computed values aren't allowed
         // in string enums, so otherwise we would have to have the constant value
-        reflection.type = new models_1.IntrinsicType("number");
+        reflection.type = new IntrinsicType("number");
     }
     context.finalizeDeclarationReflection(reflection);
 }
 function convertNamespace(context, symbol, exportSymbol) {
-    let exportFlags = typescript_1.default.SymbolFlags.ModuleMember;
+    let exportFlags = ts.SymbolFlags.ModuleMember;
     // This can happen in JS land where "class" functions get tagged as a namespace too
     if (symbol
         .getDeclarations()
-        ?.some((d) => typescript_1.default.isModuleDeclaration(d) || typescript_1.default.isSourceFile(d)) !==
+        ?.some((d) => ts.isModuleDeclaration(d) || ts.isSourceFile(d)) !==
         true) {
-        exportFlags = typescript_1.default.SymbolFlags.ClassMember;
-        if ((0, enum_1.hasAnyFlag)(symbol.flags, typescript_1.default.SymbolFlags.Class)) {
+        exportFlags = ts.SymbolFlags.ClassMember;
+        if (hasAnyFlag(symbol.flags, ts.SymbolFlags.Class)) {
             return;
         }
     }
     // #2364, @namespace on a variable might be merged with a namespace containing types.
     const existingReflection = context.project.getReflectionFromSymbol(exportSymbol || symbol);
     let reflection;
-    if (existingReflection?.kind === models_1.ReflectionKind.Namespace) {
+    if (existingReflection?.kind === ReflectionKind.Namespace) {
         reflection = existingReflection;
     }
     else {
-        reflection = context.createDeclarationReflection(models_1.ReflectionKind.Namespace, symbol, exportSymbol);
+        reflection = context.createDeclarationReflection(ReflectionKind.Namespace, symbol, exportSymbol);
         context.finalizeDeclarationReflection(reflection);
     }
     convertSymbols(context.withScope(reflection), context.checker
@@ -185,38 +179,44 @@ function convertNamespace(context, symbol, exportSymbol) {
 function convertTypeAlias(context, symbol, exportSymbol) {
     const declaration = symbol
         .getDeclarations()
-        ?.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)) {
+        ?.find((d) => ts.isTypeAliasDeclaration(d) ||
+        ts.isJSDocTypedefTag(d) ||
+        ts.isJSDocCallbackTag(d) ||
+        ts.isJSDocEnumTag(d));
+    assert(declaration);
+    if (ts.isTypeAliasDeclaration(declaration)) {
         if (context
-            .getComment(symbol, models_1.ReflectionKind.TypeAlias)
+            .getComment(symbol, ReflectionKind.TypeAlias)
             ?.hasModifier("@interface")) {
             return convertTypeAliasAsInterface(context, symbol, exportSymbol, declaration);
         }
-        const reflection = context.createDeclarationReflection(models_1.ReflectionKind.TypeAlias, symbol, exportSymbol);
-        reflection.type = context.converter.convertType(context.withScope(reflection), declaration.type);
+        const reflection = context.createDeclarationReflection(ReflectionKind.TypeAlias, symbol, exportSymbol);
+        if (reflection.comment?.hasModifier("@useDeclaredType")) {
+            reflection.comment.removeModifier("@useDeclaredType");
+            reflection.type = context.converter.convertType(context.withScope(reflection), context.checker.getDeclaredTypeOfSymbol(symbol));
+        }
+        else {
+            reflection.type = context.converter.convertType(context.withScope(reflection), declaration.type);
+        }
         if (reflection.type.type === "union") {
             attachUnionComments(context, declaration, reflection.type);
         }
         context.finalizeDeclarationReflection(reflection);
         // Do this after finalization so that the CommentPlugin can get @typeParam tags
         // 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)));
+        reflection.typeParameters = declaration.typeParameters?.map((param) => createTypeParamReflection(param, context.withScope(reflection)));
     }
-    else if (typescript_1.default.isJSDocTypedefTag(declaration) ||
-        typescript_1.default.isJSDocEnumTag(declaration)) {
-        (0, jsdoc_1.convertJsDocAlias)(context, symbol, declaration, exportSymbol);
+    else if (ts.isJSDocTypedefTag(declaration) ||
+        ts.isJSDocEnumTag(declaration)) {
+        convertJsDocAlias(context, symbol, declaration, exportSymbol);
     }
     else {
-        (0, jsdoc_1.convertJsDocCallback)(context, symbol, declaration, exportSymbol);
+        convertJsDocCallback(context, symbol, declaration, exportSymbol);
     }
 }
 function attachUnionComments(context, declaration, union) {
     const list = declaration.type.getChildAt(0);
-    if (list.kind !== typescript_1.default.SyntaxKind.SyntaxList)
+    if (list.kind !== ts.SyntaxKind.SyntaxList)
         return;
     let unionIndex = 0;
     for (const child of list.getChildren()) {
@@ -228,17 +228,17 @@ function attachUnionComments(context, declaration, union) {
             union.elementSummaries ||= Array.from({ length: union.types.length }, () => []);
             union.elementSummaries[unionIndex] = comment.summary;
         }
-        if (child.kind !== typescript_1.default.SyntaxKind.BarToken) {
+        if (child.kind !== ts.SyntaxKind.BarToken) {
             ++unionIndex;
         }
     }
 }
 function convertTypeAliasAsInterface(context, symbol, exportSymbol, declaration) {
-    const reflection = context.createDeclarationReflection(models_1.ReflectionKind.Interface, symbol, exportSymbol);
+    const reflection = context.createDeclarationReflection(ReflectionKind.Interface, symbol, exportSymbol);
     context.finalizeDeclarationReflection(reflection);
     const rc = context.withScope(reflection);
     const type = context.checker.getTypeAtLocation(declaration);
-    if (type.getFlags() & typescript_1.default.TypeFlags.Union) {
+    if (type.getFlags() & ts.TypeFlags.Union) {
         context.logger.warn(context.i18n.converting_union_as_interface(), declaration);
     }
     // Interfaces have properties
@@ -247,51 +247,51 @@ function convertTypeAliasAsInterface(context, symbol, exportSymbol, declaration)
     if (declaration.typeParameters) {
         reflection.typeParameters = declaration.typeParameters.map((param) => {
             const declaration = param.symbol?.declarations?.[0];
-            (0, assert_1.default)(declaration && typescript_1.default.isTypeParameterDeclaration(declaration));
-            return (0, signature_1.createTypeParamReflection)(declaration, rc);
+            assert(declaration && ts.isTypeParameterDeclaration(declaration));
+            return createTypeParamReflection(declaration, rc);
         });
     }
     // And maybe call signatures
     context.checker
-        .getSignaturesOfType(type, typescript_1.default.SignatureKind.Call)
-        .forEach((sig) => (0, signature_1.createSignature)(rc, models_1.ReflectionKind.CallSignature, sig, symbol));
+        .getSignaturesOfType(type, ts.SignatureKind.Call)
+        .forEach((sig) => createSignature(rc, ReflectionKind.CallSignature, sig, symbol));
     // And maybe constructor signatures
     convertConstructSignatures(rc, symbol);
     // And finally, index signatures
-    (0, index_signature_1.convertIndexSignatures)(rc, symbol);
+    convertIndexSignatures(rc, symbol);
 }
 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 &
-        (typescript_1.default.SymbolFlags.Property | typescript_1.default.SymbolFlags.Method));
+        (ts.SymbolFlags.Property | ts.SymbolFlags.Method));
     if (!isMethod) {
-        const comment = context.getComment(symbol, models_1.ReflectionKind.Function);
+        const comment = context.getComment(symbol, ReflectionKind.Function);
         if (comment?.hasModifier("@class")) {
             return convertSymbolAsClass(context, symbol, exportSymbol);
         }
     }
-    const declarations = symbol.getDeclarations()?.filter(typescript_1.default.isFunctionLike) ?? [];
+    const declarations = symbol.getDeclarations()?.filter(ts.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)(typescript_1.default.getCombinedModifierFlags(declarations[0]), typescript_1.default.ModifierFlags.Private)) {
+        hasAllFlags(ts.getCombinedModifierFlags(declarations[0]), ts.ModifierFlags.Private)) {
         return;
     }
     const locationDeclaration = symbol.parent
         ?.getDeclarations()
-        ?.find((d) => typescript_1.default.isClassDeclaration(d) || typescript_1.default.isInterfaceDeclaration(d)) ??
+        ?.find((d) => ts.isClassDeclaration(d) || ts.isInterfaceDeclaration(d)) ??
         symbol.parent?.getDeclarations()?.[0]?.getSourceFile() ??
         symbol.getDeclarations()?.[0]?.getSourceFile();
-    (0, assert_1.default)(locationDeclaration, "Missing declaration context");
+    assert(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.
     const signatures = type.getNonNullableType().getCallSignatures();
-    const reflection = context.createDeclarationReflection(context.scope.kindOf(models_1.ReflectionKind.MethodContainer)
-        ? models_1.ReflectionKind.Method
-        : models_1.ReflectionKind.Function, symbol, exportSymbol, void 0);
+    const reflection = context.createDeclarationReflection(context.scope.kindOf(ReflectionKind.MethodContainer)
+        ? ReflectionKind.Method
+        : ReflectionKind.Function, symbol, exportSymbol, void 0);
     if (symbol.declarations?.length && isMethod) {
         // All method signatures must have the same modifier flags.
         setModifiers(symbol, symbol.declarations[0], reflection);
@@ -299,34 +299,34 @@ function convertFunctionOrMethod(context, symbol, exportSymbol) {
     context.finalizeDeclarationReflection(reflection);
     const scope = context.withScope(reflection);
     for (const sig of signatures) {
-        (0, signature_1.createSignature)(scope, models_1.ReflectionKind.CallSignature, sig, symbol);
+        createSignature(scope, ReflectionKind.CallSignature, sig, symbol);
     }
     return convertFunctionProperties(scope, symbol, type);
 }
 // getDeclaredTypeOfSymbol gets the INSTANCE type
 // getTypeOfSymbolAtLocation gets the STATIC type
 function convertClassOrInterface(context, symbol, exportSymbol) {
-    const reflection = context.createDeclarationReflection(typescript_1.default.SymbolFlags.Class & symbol.flags
-        ? models_1.ReflectionKind.Class
-        : models_1.ReflectionKind.Interface, symbol, exportSymbol, void 0);
+    const reflection = context.createDeclarationReflection(ts.SymbolFlags.Class & symbol.flags
+        ? ReflectionKind.Class
+        : ReflectionKind.Interface, symbol, exportSymbol, void 0);
     const classDeclaration = symbol
         .getDeclarations()
-        ?.find((d) => typescript_1.default.isClassDeclaration(d) || typescript_1.default.isFunctionDeclaration(d));
+        ?.find((d) => ts.isClassDeclaration(d) || ts.isFunctionDeclaration(d));
     if (classDeclaration)
         setModifiers(symbol, classDeclaration, reflection);
     const reflectionContext = context.withScope(reflection);
     reflectionContext.convertingClassOrInterface = true;
     const instanceType = context.checker.getDeclaredTypeOfSymbol(symbol);
-    (0, assert_1.default)(instanceType.isClassOrInterface());
+    assert(instanceType.isClassOrInterface());
     // We might do some inheritance - do this first so that it's set when converting properties
     const declarations = symbol
         .getDeclarations()
-        ?.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));
+        ?.filter((d) => ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) ?? [];
+    const extendedTypes = getHeritageTypes(declarations, ts.SyntaxKind.ExtendsKeyword).map((t) => context.converter.convertType(reflectionContext, t));
     if (extendedTypes.length) {
         reflection.extendedTypes = extendedTypes;
     }
-    const implementedTypes = (0, nodes_1.getHeritageTypes)(declarations, typescript_1.default.SyntaxKind.ImplementsKeyword).map((t) => context.converter.convertType(reflectionContext, t));
+    const implementedTypes = getHeritageTypes(declarations, ts.SyntaxKind.ImplementsKeyword).map((t) => context.converter.convertType(reflectionContext, t));
     if (implementedTypes.length) {
         reflection.implementedTypes = implementedTypes;
     }
@@ -338,13 +338,13 @@ 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 &
-                (typescript_1.default.SymbolFlags.ModuleMember | typescript_1.default.SymbolFlags.Prototype))
+                (ts.SymbolFlags.ModuleMember | ts.SymbolFlags.Prototype))
                 continue;
             convertSymbol(reflectionContext, prop);
         }
         reflectionContext.shouldBeStatic = false;
         const ctors = staticType.getConstructSignatures();
-        const constructMember = reflectionContext.createDeclarationReflection(models_1.ReflectionKind.Constructor, ctors[0]?.declaration?.symbol, void 0, "constructor");
+        const constructMember = reflectionContext.createDeclarationReflection(ReflectionKind.Constructor, ctors[0]?.declaration?.symbol, void 0, "constructor");
         // Modifiers are the same for all constructors
         if (ctors.length && ctors[0].declaration) {
             setModifiers(symbol, ctors[0].declaration, constructMember);
@@ -352,7 +352,7 @@ function convertClassOrInterface(context, symbol, exportSymbol) {
         context.finalizeDeclarationReflection(constructMember);
         const constructContext = reflectionContext.withScope(constructMember);
         ctors.forEach((sig) => {
-            (0, signature_1.createSignature)(constructContext, models_1.ReflectionKind.ConstructorSignature, sig, symbol);
+            createSignature(constructContext, ReflectionKind.ConstructorSignature, sig, symbol);
         });
     }
     // Classes/interfaces usually just have properties...
@@ -361,119 +361,122 @@ function convertClassOrInterface(context, symbol, exportSymbol) {
     if (instanceType.typeParameters) {
         reflection.typeParameters = instanceType.typeParameters.map((param) => {
             const declaration = param.symbol.declarations?.[0];
-            (0, assert_1.default)(declaration && typescript_1.default.isTypeParameterDeclaration(declaration));
-            return (0, signature_1.createTypeParamReflection)(declaration, reflectionContext);
+            assert(declaration && ts.isTypeParameterDeclaration(declaration));
+            return createTypeParamReflection(declaration, reflectionContext);
         });
     }
     // Interfaces might also have call signatures
     // Classes might too, because of declaration merging
     context.checker
-        .getSignaturesOfType(instanceType, typescript_1.default.SignatureKind.Call)
-        .forEach((sig) => (0, signature_1.createSignature)(reflectionContext, models_1.ReflectionKind.CallSignature, sig, symbol));
+        .getSignaturesOfType(instanceType, ts.SignatureKind.Call)
+        .forEach((sig) => createSignature(reflectionContext, ReflectionKind.CallSignature, sig, symbol));
     // We also might have constructor signatures
     // This is potentially a problem with classes having multiple "constructor" members...
     // but nobody has complained yet.
     convertConstructSignatures(reflectionContext, symbol);
     // And finally, index signatures
-    (0, index_signature_1.convertIndexSignatures)(reflectionContext, symbol);
+    convertIndexSignatures(reflectionContext, symbol);
     // Normally this shouldn't matter, unless someone did something with skipLibCheck on.
-    return typescript_1.default.SymbolFlags.Alias;
+    return ts.SymbolFlags.Alias;
 }
 function convertProperty(context, symbol, exportSymbol) {
     // This might happen if we're converting a function-module created with Object.assign
     // or `export default () => {}`
-    if (context.scope.kindOf(models_1.ReflectionKind.VariableContainer)) {
+    if (context.scope.kindOf(ReflectionKind.VariableContainer)) {
         return convertVariable(context, symbol, exportSymbol);
     }
     const declarations = symbol.getDeclarations() ?? [];
     // Don't do anything if we inherited this property and it is private.
     if (isInherited(context, symbol) &&
         declarations.length > 0 &&
-        (0, enum_1.hasAllFlags)(typescript_1.default.getCombinedModifierFlags(declarations[0]), typescript_1.default.ModifierFlags.Private)) {
+        hasAllFlags(ts.getCombinedModifierFlags(declarations[0]), ts.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) => typescript_1.default.isMethodSignature(decl) || typescript_1.default.isMethodDeclaration(decl))) {
+        declarations.every((decl) => ts.isMethodSignature(decl) || ts.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 (typescript_1.default.isPropertyDeclaration(declaration) &&
+        if (ts.isPropertyDeclaration(declaration) &&
             !declaration.type &&
             declaration.initializer &&
-            typescript_1.default.isArrowFunction(declaration.initializer)) {
+            ts.isArrowFunction(declaration.initializer)) {
             return convertArrowAsMethod(context, symbol, declaration.initializer, exportSymbol);
         }
     }
-    const reflection = context.createDeclarationReflection(context.scope.kindOf(models_1.ReflectionKind.VariableContainer)
-        ? models_1.ReflectionKind.Variable
-        : models_1.ReflectionKind.Property, symbol, exportSymbol);
+    const reflection = context.createDeclarationReflection(context.scope.kindOf(ReflectionKind.VariableContainer)
+        ? ReflectionKind.Variable
+        : ReflectionKind.Property, symbol, exportSymbol);
     const declaration = symbol.getDeclarations()?.[0];
     let parameterType;
     if (declaration &&
-        (typescript_1.default.isPropertyDeclaration(declaration) ||
-            typescript_1.default.isPropertySignature(declaration) ||
-            typescript_1.default.isParameter(declaration) ||
-            typescript_1.default.isPropertyAccessExpression(declaration) ||
-            typescript_1.default.isPropertyAssignment(declaration))) {
-        if (!typescript_1.default.isPropertyAccessExpression(declaration) &&
-            !typescript_1.default.isPropertyAssignment(declaration)) {
+        (ts.isPropertyDeclaration(declaration) ||
+            ts.isPropertySignature(declaration) ||
+            ts.isParameter(declaration) ||
+            ts.isPropertyAccessExpression(declaration) ||
+            ts.isPropertyAssignment(declaration))) {
+        if (!ts.isPropertyAccessExpression(declaration) &&
+            !ts.isPropertyAssignment(declaration)) {
             parameterType = declaration.type;
         }
         setModifiers(symbol, declaration, reflection);
     }
-    reflection.defaultValue = declaration && (0, convert_expression_1.convertDefaultValue)(declaration);
+    else {
+        setSymbolModifiers(symbol, reflection);
+    }
+    reflection.defaultValue = declaration && convertDefaultValue(declaration);
     reflection.type = context.converter.convertType(context.withScope(reflection), (context.convertingTypeNode ? parameterType : void 0) ??
         context.checker.getTypeOfSymbol(symbol));
     if (reflection.flags.isOptional) {
-        reflection.type = (0, reflections_1.removeUndefined)(reflection.type);
+        reflection.type = removeUndefined(reflection.type);
     }
     context.finalizeDeclarationReflection(reflection);
 }
 function convertArrowAsMethod(context, symbol, arrow, exportSymbol) {
-    const reflection = context.createDeclarationReflection(models_1.ReflectionKind.Method, symbol, exportSymbol, void 0);
+    const reflection = context.createDeclarationReflection(ReflectionKind.Method, symbol, exportSymbol, void 0);
     setModifiers(symbol, arrow.parent, reflection);
     context.finalizeDeclarationReflection(reflection);
     const rc = context.withScope(reflection);
     const locationDeclaration = symbol.parent
         ?.getDeclarations()
-        ?.find((d) => typescript_1.default.isClassDeclaration(d) || typescript_1.default.isInterfaceDeclaration(d)) ??
+        ?.find((d) => ts.isClassDeclaration(d) || ts.isInterfaceDeclaration(d)) ??
         symbol.parent?.getDeclarations()?.[0]?.getSourceFile() ??
         symbol.getDeclarations()?.[0]?.getSourceFile();
-    (0, assert_1.default)(locationDeclaration, "Missing declaration context");
+    assert(locationDeclaration, "Missing declaration context");
     const type = context.checker.getTypeOfSymbolAtLocation(symbol, locationDeclaration);
     const signatures = type.getNonNullableType().getCallSignatures();
-    (0, assert_1.default)(signatures.length, "Missing signatures");
-    (0, signature_1.createSignature)(rc, models_1.ReflectionKind.CallSignature, signatures[0], symbol, arrow);
+    assert(signatures.length, "Missing signatures");
+    createSignature(rc, ReflectionKind.CallSignature, signatures[0], symbol, arrow);
 }
 function convertConstructor(context, symbol) {
-    const reflection = context.createDeclarationReflection(models_1.ReflectionKind.Constructor, symbol, void 0, "constructor");
+    const reflection = context.createDeclarationReflection(ReflectionKind.Constructor, symbol, void 0, "constructor");
     context.finalizeDeclarationReflection(reflection);
     const reflectionContext = context.withScope(reflection);
-    const declarations = symbol.getDeclarations()?.filter(typescript_1.default.isConstructorDeclaration) ?? [];
+    const declarations = symbol.getDeclarations()?.filter(ts.isConstructorDeclaration) ?? [];
     const signatures = declarations.map((decl) => {
         const sig = context.checker.getSignatureFromDeclaration(decl);
-        (0, assert_1.default)(sig);
+        assert(sig);
         return sig;
     });
     for (const sig of signatures) {
-        (0, signature_1.createSignature)(reflectionContext, models_1.ReflectionKind.ConstructorSignature, sig, symbol);
+        createSignature(reflectionContext, ReflectionKind.ConstructorSignature, sig, symbol);
     }
 }
 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, typescript_1.default.SignatureKind.Construct);
+    const constructSignatures = context.checker.getSignaturesOfType(type, ts.SignatureKind.Construct);
     if (constructSignatures.length) {
-        const constructMember = new models_1.DeclarationReflection("constructor", models_1.ReflectionKind.Constructor, context.scope);
+        const constructMember = new DeclarationReflection("constructor", ReflectionKind.Constructor, context.scope);
         context.postReflectionCreation(constructMember, symbol, void 0);
         context.finalizeDeclarationReflection(constructMember);
         const constructContext = context.withScope(constructMember);
-        constructSignatures.forEach((sig) => (0, signature_1.createSignature)(constructContext, models_1.ReflectionKind.ConstructorSignature, sig, symbol));
+        constructSignatures.forEach((sig) => createSignature(constructContext, ReflectionKind.ConstructorSignature, sig, symbol));
     }
 }
 function convertAlias(context, symbol, exportSymbol) {
@@ -490,13 +493,13 @@ function createAlias(target, context, symbol, exportSymbol) {
     if (context.converter.excludeReferences)
         return;
     // We already have this. Create a reference.
-    const ref = new models_1.ReferenceReflection(exportSymbol?.name ?? symbol.name, target, context.scope);
+    const ref = new ReferenceReflection(exportSymbol?.name ?? symbol.name, target, context.scope);
     context.postReflectionCreation(ref, symbol, exportSymbol);
     context.finalizeDeclarationReflection(ref);
 }
 function convertVariable(context, symbol, exportSymbol) {
     const declaration = symbol.getDeclarations()?.[0];
-    const comment = context.getComment(symbol, models_1.ReflectionKind.Variable);
+    const comment = context.getComment(symbol, ReflectionKind.Variable);
     const type = declaration
         ? context.checker.getTypeOfSymbolAtLocation(symbol, declaration)
         : context.checker.getTypeOfSymbol(symbol);
@@ -514,22 +517,22 @@ function convertVariable(context, symbol, exportSymbol) {
         !type.getConstructSignatures().length) {
         return convertVariableAsFunction(context, symbol, exportSymbol);
     }
-    const reflection = context.createDeclarationReflection(context.scope.kindOf(models_1.ReflectionKind.VariableContainer)
-        ? models_1.ReflectionKind.Variable
-        : models_1.ReflectionKind.Property, symbol, exportSymbol);
+    const reflection = context.createDeclarationReflection(context.scope.kindOf(ReflectionKind.VariableContainer)
+        ? ReflectionKind.Variable
+        : ReflectionKind.Property, symbol, exportSymbol);
     let typeNode;
-    if (declaration && typescript_1.default.isVariableDeclaration(declaration)) {
+    if (declaration && ts.isVariableDeclaration(declaration)) {
         // Otherwise we might have destructuring
         typeNode = declaration.type;
     }
     reflection.type = context.converter.convertType(context.withScope(reflection), typeNode ?? type);
     setModifiers(symbol, declaration, reflection);
-    reflection.defaultValue = (0, convert_expression_1.convertDefaultValue)(declaration);
+    reflection.defaultValue = convertDefaultValue(declaration);
     context.finalizeDeclarationReflection(reflection);
-    return typescript_1.default.SymbolFlags.Property;
+    return ts.SymbolFlags.Property;
 }
 function isEnumLike(checker, type, location) {
-    if (!location || !(0, enum_1.hasAllFlags)(type.flags, typescript_1.default.TypeFlags.Object)) {
+    if (!location || !hasAllFlags(type.flags, ts.TypeFlags.Object)) {
         return false;
     }
     return type.getProperties().every((prop) => {
@@ -538,51 +541,51 @@ function isEnumLike(checker, type, location) {
     });
 }
 function isValidEnumProperty(type) {
-    return (0, enum_1.hasAnyFlag)(type.flags, typescript_1.default.TypeFlags.NumberLike | typescript_1.default.TypeFlags.StringLike);
+    return hasAnyFlag(type.flags, ts.TypeFlags.NumberLike | ts.TypeFlags.StringLike);
 }
 function convertVariableAsEnum(context, symbol, exportSymbol) {
-    const reflection = context.createDeclarationReflection(models_1.ReflectionKind.Enum, symbol, exportSymbol);
+    const reflection = context.createDeclarationReflection(ReflectionKind.Enum, symbol, exportSymbol);
     context.finalizeDeclarationReflection(reflection);
     const rc = context.withScope(reflection);
-    const declaration = symbol.declarations[0];
+    const declaration = symbol.declarations.find(ts.isVariableDeclaration);
     const type = context.checker.getTypeAtLocation(declaration);
     for (const prop of type.getProperties()) {
-        const reflection = rc.createDeclarationReflection(models_1.ReflectionKind.EnumMember, prop, void 0);
+        const reflection = rc.createDeclarationReflection(ReflectionKind.EnumMember, prop, void 0);
         const propType = context.checker.getTypeOfSymbolAtLocation(prop, declaration);
-        reflection.type = context.converter.convertType(context, propType);
+        reflection.type = context.converter.convertType(rc.withScope(reflection), propType);
         rc.finalizeDeclarationReflection(reflection);
     }
     // Skip converting the type alias, if there is one
-    return typescript_1.default.SymbolFlags.TypeAlias;
+    return ts.SymbolFlags.TypeAlias;
 }
 function convertVariableAsNamespace(context, symbol, exportSymbol) {
-    const reflection = context.createDeclarationReflection(models_1.ReflectionKind.Namespace, symbol, exportSymbol);
+    const reflection = context.createDeclarationReflection(ReflectionKind.Namespace, symbol, exportSymbol);
     context.finalizeDeclarationReflection(reflection);
     const rc = context.withScope(reflection);
     const type = context.checker.getTypeOfSymbol(symbol);
     convertSymbols(rc, type.getProperties());
-    return typescript_1.default.SymbolFlags.Property;
+    return ts.SymbolFlags.Property;
 }
 function convertVariableAsFunction(context, symbol, exportSymbol) {
     const declaration = symbol
         .getDeclarations()
-        ?.find(typescript_1.default.isVariableDeclaration);
+        ?.find(ts.isVariableDeclaration);
     const accessDeclaration = declaration ?? symbol.valueDeclaration;
     const type = accessDeclaration
         ? context.checker.getTypeOfSymbolAtLocation(symbol, accessDeclaration)
         : context.checker.getDeclaredTypeOfSymbol(symbol);
-    const reflection = context.createDeclarationReflection(context.scope.kindOf(models_1.ReflectionKind.MethodContainer)
-        ? models_1.ReflectionKind.Method
-        : models_1.ReflectionKind.Function, symbol, exportSymbol);
+    const reflection = context.createDeclarationReflection(context.scope.kindOf(ReflectionKind.MethodContainer)
+        ? ReflectionKind.Method
+        : ReflectionKind.Function, symbol, exportSymbol);
     setModifiers(symbol, accessDeclaration, reflection);
     context.finalizeDeclarationReflection(reflection);
     const reflectionContext = context.withScope(reflection);
     reflection.signatures ??= [];
     for (const signature of type.getCallSignatures()) {
-        (0, signature_1.createSignature)(reflectionContext, models_1.ReflectionKind.CallSignature, signature, symbol);
+        createSignature(reflectionContext, ReflectionKind.CallSignature, signature, symbol);
     }
     return (convertFunctionProperties(context.withScope(reflection), symbol, type) |
-        typescript_1.default.SymbolFlags.Property);
+        ts.SymbolFlags.Property);
 }
 function convertFunctionProperties(context, symbol, type) {
     // #2436/#2461: Functions created with Object.assign on a function likely have properties
@@ -592,17 +595,17 @@ function convertFunctionProperties(context, symbol, type) {
     // rather than creating a separate namespace.
     // In the expando case, we'll have both namespace flags.
     // In the Object.assign case, we'll have no namespace flags.
-    const nsFlags = typescript_1.default.SymbolFlags.ValueModule | typescript_1.default.SymbolFlags.NamespaceModule;
+    const nsFlags = ts.SymbolFlags.ValueModule | ts.SymbolFlags.NamespaceModule;
     if (type.getProperties().length &&
-        ((0, enum_1.hasAllFlags)(symbol.flags, nsFlags) ||
-            !(0, enum_1.hasAnyFlag)(symbol.flags, nsFlags))) {
+        (hasAllFlags(symbol.flags, nsFlags) ||
+            !hasAnyFlag(symbol.flags, nsFlags))) {
         convertSymbols(context, type.getProperties());
-        return typescript_1.default.SymbolFlags.NamespaceModule;
+        return ts.SymbolFlags.NamespaceModule;
     }
-    return typescript_1.default.SymbolFlags.None;
+    return ts.SymbolFlags.None;
 }
 function convertSymbolAsClass(context, symbol, exportSymbol) {
-    const reflection = context.createDeclarationReflection(models_1.ReflectionKind.Class, symbol, exportSymbol);
+    const reflection = context.createDeclarationReflection(ReflectionKind.Class, symbol, exportSymbol);
     const rc = context.withScope(reflection);
     context.finalizeDeclarationReflection(reflection);
     if (!symbol.valueDeclaration) {
@@ -615,12 +618,12 @@ function convertSymbolAsClass(context, symbol, exportSymbol) {
     // Prototype is implicitly this class, don't document it.
     type.getProperties().filter((prop) => prop.name !== "prototype"));
     for (const sig of type.getCallSignatures()) {
-        (0, signature_1.createSignature)(rc, models_1.ReflectionKind.CallSignature, sig, undefined);
+        createSignature(rc, ReflectionKind.CallSignature, sig, undefined);
     }
     rc.shouldBeStatic = false;
     const ctors = type.getConstructSignatures();
     if (ctors.length) {
-        const constructMember = rc.createDeclarationReflection(models_1.ReflectionKind.Constructor, ctors[0]?.declaration?.symbol, void 0, "constructor");
+        const constructMember = rc.createDeclarationReflection(ReflectionKind.Constructor, ctors[0]?.declaration?.symbol, void 0, "constructor");
         // Modifiers are the same for all constructors
         if (ctors.length && ctors[0].declaration) {
             setModifiers(symbol, ctors[0].declaration, constructMember);
@@ -628,41 +631,41 @@ function convertSymbolAsClass(context, symbol, exportSymbol) {
         context.finalizeDeclarationReflection(constructMember);
         const constructContext = rc.withScope(constructMember);
         for (const sig of ctors) {
-            (0, signature_1.createConstructSignatureWithType)(constructContext, sig, reflection);
+            createConstructSignatureWithType(constructContext, sig, reflection);
         }
         const instType = ctors[0].getReturnType();
         convertSymbols(rc, instType.getProperties());
         for (const sig of instType.getCallSignatures()) {
-            (0, signature_1.createSignature)(rc, models_1.ReflectionKind.CallSignature, sig, undefined);
+            createSignature(rc, ReflectionKind.CallSignature, sig, undefined);
         }
     }
     else {
         context.logger.warn(context.i18n.converting_0_as_class_without_construct_signatures(reflection.getFriendlyFullName()), symbol.valueDeclaration);
     }
-    return (typescript_1.default.SymbolFlags.TypeAlias |
-        typescript_1.default.SymbolFlags.Interface |
-        typescript_1.default.SymbolFlags.Namespace);
+    return (ts.SymbolFlags.TypeAlias |
+        ts.SymbolFlags.Interface |
+        ts.SymbolFlags.Namespace);
 }
 function convertAccessor(context, symbol, exportSymbol) {
-    const reflection = context.createDeclarationReflection(models_1.ReflectionKind.Accessor, symbol, exportSymbol);
+    const reflection = context.createDeclarationReflection(ReflectionKind.Accessor, symbol, exportSymbol);
     const rc = context.withScope(reflection);
     const declaration = symbol.getDeclarations()?.[0];
     if (declaration) {
         setModifiers(symbol, declaration, reflection);
     }
     context.finalizeDeclarationReflection(reflection);
-    const getDeclaration = symbol.getDeclarations()?.find(typescript_1.default.isGetAccessor);
+    const getDeclaration = symbol.getDeclarations()?.find(ts.isGetAccessor);
     if (getDeclaration) {
         const signature = context.checker.getSignatureFromDeclaration(getDeclaration);
         if (signature) {
-            (0, signature_1.createSignature)(rc, models_1.ReflectionKind.GetSignature, signature, symbol, getDeclaration);
+            createSignature(rc, ReflectionKind.GetSignature, signature, symbol, getDeclaration);
         }
     }
-    const setDeclaration = symbol.getDeclarations()?.find(typescript_1.default.isSetAccessor);
+    const setDeclaration = symbol.getDeclarations()?.find(ts.isSetAccessor);
     if (setDeclaration) {
         const signature = context.checker.getSignatureFromDeclaration(setDeclaration);
         if (signature) {
-            (0, signature_1.createSignature)(rc, models_1.ReflectionKind.SetSignature, signature, symbol, setDeclaration);
+            createSignature(rc, ReflectionKind.SetSignature, signature, symbol, setDeclaration);
         }
     }
 }
@@ -673,41 +676,45 @@ function isInherited(context, symbol) {
     if (!parentSymbol)
         return false;
     const parents = parentSymbol.declarations?.slice() || [];
-    const constructorDecls = parents.flatMap((parent) => typescript_1.default.isClassDeclaration(parent)
-        ? parent.members.filter(typescript_1.default.isConstructorDeclaration)
+    const constructorDecls = parents.flatMap((parent) => ts.isClassDeclaration(parent)
+        ? parent.members.filter(ts.isConstructorDeclaration)
         : []);
     parents.push(...constructorDecls);
     return (parents.some((d) => symbol.getDeclarations()?.some((d2) => d2.parent === d)) === false);
 }
 function setModifiers(symbol, declaration, reflection) {
+    setSymbolModifiers(symbol, reflection);
     if (!declaration) {
         return;
     }
-    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);
+    const modifiers = ts.getCombinedModifierFlags(declaration);
+    if (ts.isMethodDeclaration(declaration) ||
+        ts.isPropertyDeclaration(declaration) ||
+        ts.isAccessor(declaration)) {
+        if (ts.isPrivateIdentifier(declaration.name)) {
+            reflection.setFlag(ReflectionFlag.Private);
         }
     }
-    if ((0, enum_1.hasAllFlags)(modifiers, typescript_1.default.ModifierFlags.Private)) {
-        reflection.setFlag(models_1.ReflectionFlag.Private);
+    if (hasAllFlags(modifiers, ts.ModifierFlags.Private)) {
+        reflection.setFlag(ReflectionFlag.Private);
     }
-    if ((0, enum_1.hasAllFlags)(modifiers, typescript_1.default.ModifierFlags.Protected)) {
-        reflection.setFlag(models_1.ReflectionFlag.Protected);
+    if (hasAllFlags(modifiers, ts.ModifierFlags.Protected)) {
+        reflection.setFlag(ReflectionFlag.Protected);
     }
-    if ((0, enum_1.hasAllFlags)(modifiers, typescript_1.default.ModifierFlags.Public)) {
-        reflection.setFlag(models_1.ReflectionFlag.Public);
+    if (hasAllFlags(modifiers, ts.ModifierFlags.Public)) {
+        reflection.setFlag(ReflectionFlag.Public);
     }
-    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)(typescript_1.default.getCheckFlags(symbol), 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, typescript_1.default.SymbolFlags.BlockScopedVariable)) {
-        reflection.setFlag(models_1.ReflectionFlag.Const, (0, enum_1.hasAllFlags)(declaration.parent.flags, typescript_1.default.NodeFlags.Const));
+    reflection.setFlag(ReflectionFlag.Optional, hasAllFlags(symbol.flags, ts.SymbolFlags.Optional));
+    reflection.setFlag(ReflectionFlag.Readonly, hasAllFlags(ts.getCheckFlags(symbol), ts.CheckFlags.Readonly) ||
+        hasAllFlags(modifiers, ts.ModifierFlags.Readonly));
+    reflection.setFlag(ReflectionFlag.Abstract, hasAllFlags(modifiers, ts.ModifierFlags.Abstract));
+    if (reflection.kindOf(ReflectionKind.Variable) &&
+        hasAllFlags(symbol.flags, ts.SymbolFlags.BlockScopedVariable)) {
+        reflection.setFlag(ReflectionFlag.Const, hasAllFlags(declaration.parent.flags, ts.NodeFlags.Const));
     }
     // ReflectionFlag.Static happens when constructing the reflection.
     // We don't have sufficient information here to determine if it ought to be static.
 }
+function setSymbolModifiers(symbol, reflection) {
+    reflection.setFlag(ReflectionFlag.Optional, hasAllFlags(symbol.flags, ts.SymbolFlags.Optional));
+}