typedoc 0.26.11 → 0.27.0-beta.1

package/dist/lib/converter/types.js

@@ -1,23 +1,16 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadConverters = loadConverters;
-exports.convertType = convertType;
-const assert_1 = __importDefault(require("assert"));
-const typescript_1 = __importDefault(require("typescript"));
-const models_1 = require("../models");
-const ReflectionSymbolId_1 = require("../models/reflections/ReflectionSymbolId");
-const array_1 = require("../utils/array");
-const converter_events_1 = require("./converter-events");
-const index_signature_1 = require("./factories/index-signature");
-const signature_1 = require("./factories/signature");
-const symbols_1 = require("./symbols");
-const nodes_1 = require("./utils/nodes");
-const reflections_1 = require("./utils/reflections");
+import assert from "assert";
+import ts from "typescript";
+import { ArrayType, ConditionalType, DeclarationReflection, IndexedAccessType, InferredType, IntersectionType, IntrinsicType, NamedTupleMember, PredicateType, QueryType, ReferenceType, ReflectionKind, ReflectionType, LiteralType, TupleType, TypeOperatorType, UnionType, UnknownType, MappedType, SignatureReflection, ReflectionFlag, OptionalType, RestType, TemplateLiteralType, } from "../models/index.js";
+import { ReflectionSymbolId } from "../models/reflections/ReflectionSymbolId.js";
+import { zip } from "../utils/array.js";
+import { ConverterEvents } from "./converter-events.js";
+import { convertIndexSignatures } from "./factories/index-signature.js";
+import { convertParameterNodes, convertTypeParameterNodes, createSignature, } from "./factories/signature.js";
+import { convertSymbol } from "./symbols.js";
+import { isObjectType } from "./utils/nodes.js";
+import { removeUndefined } from "./utils/reflections.js";
 const converters = new Map();
-function loadConverters() {
+export function loadConverters() {
     if (converters.size)
         return;
     for (const actor of [
@@ -57,7 +50,7 @@ function loadConverters() {
                 // Might happen if running on an older TS version.
                 continue;
             }
-            (0, assert_1.default)(!converters.has(key));
+            assert(!converters.has(key));
             converters.set(key, actor);
         }
     }
@@ -72,12 +65,12 @@ function maybeConvertType(context, typeOrNode) {
     return convertType(context, typeOrNode);
 }
 let typeConversionDepth = 0;
-function convertType(context, typeOrNode) {
+export function convertType(context, typeOrNode) {
     if (!typeOrNode) {
-        return new models_1.IntrinsicType("any");
+        return new IntrinsicType("any");
     }
     if (typeConversionDepth > context.converter.maxTypeConversionDepth) {
-        return new models_1.UnknownType("...");
+        return new UnknownType("...");
     }
     loadConverters();
     if ("kind" in typeOrNode) {
@@ -99,12 +92,12 @@ function convertType(context, typeOrNode) {
         return convertType(context, typeOrNode.origin);
     }
     // IgnoreErrors is important, without it, we can't assert that we will get a node.
-    const node = context.checker.typeToTypeNode(typeOrNode, void 0, typescript_1.default.NodeBuilderFlags.IgnoreErrors);
-    (0, assert_1.default)(node); // According to the TS source of typeToString, this is a bug if it does not hold.
+    const node = context.checker.typeToTypeNode(typeOrNode, void 0, ts.NodeBuilderFlags.IgnoreErrors);
+    assert(node); // According to the TS source of typeToString, this is a bug if it does not hold.
     if (seenTypes.has(typeOrNode.id)) {
         const typeString = context.checker.typeToString(typeOrNode);
         context.logger.verbose(`Refusing to recurse when converting type: ${typeString}`);
-        return new models_1.UnknownType(typeString);
+        return new UnknownType(typeString);
     }
     let converter = converters.get(node.kind);
     if (converter) {
@@ -123,70 +116,70 @@ function convertType(context, typeOrNode) {
     return requestBugReport(context, typeOrNode);
 }
 const arrayConverter = {
-    kind: [typescript_1.default.SyntaxKind.ArrayType],
+    kind: [ts.SyntaxKind.ArrayType],
     convert(context, node) {
-        return new models_1.ArrayType(convertType(context, node.elementType));
+        return new ArrayType(convertType(context, node.elementType));
     },
     convertType(context, type) {
         const params = context.checker.getTypeArguments(type);
         // This is *almost* always true... except for when this type is in the constraint of a type parameter see GH#1408
         // assert(params.length === 1);
-        (0, assert_1.default)(params.length > 0);
-        return new models_1.ArrayType(convertType(context, params[0]));
+        assert(params.length > 0);
+        return new ArrayType(convertType(context, params[0]));
     },
 };
 const conditionalConverter = {
-    kind: [typescript_1.default.SyntaxKind.ConditionalType],
+    kind: [ts.SyntaxKind.ConditionalType],
     convert(context, node) {
-        return new models_1.ConditionalType(convertType(context, node.checkType), convertType(context, node.extendsType), convertType(context, node.trueType), convertType(context, node.falseType));
+        return new ConditionalType(convertType(context, node.checkType), convertType(context, node.extendsType), convertType(context, node.trueType), convertType(context, node.falseType));
     },
     convertType(context, type) {
-        return new models_1.ConditionalType(convertType(context, type.checkType), convertType(context, type.extendsType), convertType(context, type.resolvedTrueType), convertType(context, type.resolvedFalseType));
+        return new ConditionalType(convertType(context, type.checkType), convertType(context, type.extendsType), convertType(context, type.resolvedTrueType), convertType(context, type.resolvedFalseType));
     },
 };
 const constructorConverter = {
-    kind: [typescript_1.default.SyntaxKind.ConstructorType],
+    kind: [ts.SyntaxKind.ConstructorType],
     convert(context, node) {
         const symbol = context.getSymbolAtLocation(node) ?? node.symbol;
         const type = context.getTypeAtLocation(node);
         if (!symbol || !type) {
-            return new models_1.IntrinsicType("Function");
+            return new IntrinsicType("Function");
         }
-        const reflection = new models_1.DeclarationReflection("__type", models_1.ReflectionKind.Constructor, context.scope);
+        const reflection = new DeclarationReflection("__type", ReflectionKind.Constructor, context.scope);
         const rc = context.withScope(reflection);
         rc.convertingTypeNode = true;
         context.registerReflection(reflection, symbol);
-        context.converter.trigger(converter_events_1.ConverterEvents.CREATE_DECLARATION, context, reflection);
-        const signature = new models_1.SignatureReflection("__type", models_1.ReflectionKind.ConstructorSignature, reflection);
+        context.converter.trigger(ConverterEvents.CREATE_DECLARATION, context, reflection);
+        const signature = new SignatureReflection("__type", ReflectionKind.ConstructorSignature, reflection);
         // This is unfortunate... but seems the obvious place to put this with the current
         // architecture. Ideally, this would be a property on a "ConstructorType"... but that
         // needs to wait until TypeDoc 0.22 when making other breaking changes.
-        if (node.modifiers?.some((m) => m.kind === typescript_1.default.SyntaxKind.AbstractKeyword)) {
-            signature.setFlag(models_1.ReflectionFlag.Abstract);
+        if (node.modifiers?.some((m) => m.kind === ts.SyntaxKind.AbstractKeyword)) {
+            signature.setFlag(ReflectionFlag.Abstract);
         }
-        context.project.registerSymbolId(signature, new ReflectionSymbolId_1.ReflectionSymbolId(symbol, node));
+        context.project.registerSymbolId(signature, new ReflectionSymbolId(symbol, node));
         context.registerReflection(signature, void 0);
         const signatureCtx = rc.withScope(signature);
         reflection.signatures = [signature];
         signature.type = convertType(signatureCtx, node.type);
-        signature.parameters = (0, signature_1.convertParameterNodes)(signatureCtx, signature, node.parameters);
-        signature.typeParameters = (0, signature_1.convertTypeParameterNodes)(signatureCtx, node.typeParameters);
-        return new models_1.ReflectionType(reflection);
+        signature.parameters = convertParameterNodes(signatureCtx, signature, node.parameters);
+        signature.typeParameters = convertTypeParameterNodes(signatureCtx, node.typeParameters);
+        return new ReflectionType(reflection);
     },
     convertType(context, type) {
         const symbol = type.getSymbol();
         if (!symbol) {
-            return new models_1.IntrinsicType("Function");
+            return new IntrinsicType("Function");
         }
-        const reflection = new models_1.DeclarationReflection("__type", models_1.ReflectionKind.Constructor, context.scope);
+        const reflection = new DeclarationReflection("__type", ReflectionKind.Constructor, context.scope);
         context.registerReflection(reflection, symbol);
-        context.converter.trigger(converter_events_1.ConverterEvents.CREATE_DECLARATION, context, reflection);
-        (0, signature_1.createSignature)(context.withScope(reflection), models_1.ReflectionKind.ConstructorSignature, type.getConstructSignatures()[0], symbol);
-        return new models_1.ReflectionType(reflection);
+        context.converter.trigger(ConverterEvents.CREATE_DECLARATION, context, reflection);
+        createSignature(context.withScope(reflection), ReflectionKind.ConstructorSignature, type.getConstructSignatures()[0], symbol);
+        return new ReflectionType(reflection);
     },
 };
 const exprWithTypeArgsConverter = {
-    kind: [typescript_1.default.SyntaxKind.ExpressionWithTypeArguments],
+    kind: [ts.SyntaxKind.ExpressionWithTypeArguments],
     convert(context, node) {
         const targetSymbol = context.getSymbolAtLocation(node.expression);
         // Mixins... we might not have a symbol here.
@@ -194,149 +187,149 @@ const exprWithTypeArgsConverter = {
             return convertType(context, context.checker.getTypeAtLocation(node));
         }
         const parameters = node.typeArguments?.map((type) => convertType(context, type)) ?? [];
-        const ref = models_1.ReferenceType.createSymbolReference(context.resolveAliasedSymbol(targetSymbol), context);
+        const ref = ReferenceType.createSymbolReference(context.resolveAliasedSymbol(targetSymbol), context);
         ref.typeArguments = parameters;
         return ref;
     },
     convertType: requestBugReport,
 };
 const functionTypeConverter = {
-    kind: [typescript_1.default.SyntaxKind.FunctionType],
+    kind: [ts.SyntaxKind.FunctionType],
     convert(context, node) {
         const symbol = context.getSymbolAtLocation(node) ?? node.symbol;
         const type = context.getTypeAtLocation(node);
         if (!symbol || !type) {
-            return new models_1.IntrinsicType("Function");
+            return new IntrinsicType("Function");
         }
-        const reflection = new models_1.DeclarationReflection("__type", models_1.ReflectionKind.TypeLiteral, context.scope);
+        const reflection = new DeclarationReflection("__type", ReflectionKind.TypeLiteral, context.scope);
         const rc = context.withScope(reflection);
         context.registerReflection(reflection, symbol);
-        context.converter.trigger(converter_events_1.ConverterEvents.CREATE_DECLARATION, context, reflection);
-        const signature = new models_1.SignatureReflection("__type", models_1.ReflectionKind.CallSignature, reflection);
-        context.project.registerSymbolId(signature, new ReflectionSymbolId_1.ReflectionSymbolId(symbol, node));
+        context.converter.trigger(ConverterEvents.CREATE_DECLARATION, context, reflection);
+        const signature = new SignatureReflection("__type", ReflectionKind.CallSignature, reflection);
+        context.project.registerSymbolId(signature, new ReflectionSymbolId(symbol, node));
         context.registerReflection(signature, undefined);
         const signatureCtx = rc.withScope(signature);
         reflection.signatures = [signature];
         signature.type = convertType(signatureCtx, node.type);
-        signature.parameters = (0, signature_1.convertParameterNodes)(signatureCtx, signature, node.parameters);
-        signature.typeParameters = (0, signature_1.convertTypeParameterNodes)(signatureCtx, node.typeParameters);
-        return new models_1.ReflectionType(reflection);
+        signature.parameters = convertParameterNodes(signatureCtx, signature, node.parameters);
+        signature.typeParameters = convertTypeParameterNodes(signatureCtx, node.typeParameters);
+        return new ReflectionType(reflection);
     },
     convertType(context, type) {
         const symbol = type.getSymbol();
         if (!symbol) {
-            return new models_1.IntrinsicType("Function");
+            return new IntrinsicType("Function");
         }
-        const reflection = new models_1.DeclarationReflection("__type", models_1.ReflectionKind.TypeLiteral, context.scope);
+        const reflection = new DeclarationReflection("__type", ReflectionKind.TypeLiteral, context.scope);
         context.registerReflection(reflection, symbol);
-        context.converter.trigger(converter_events_1.ConverterEvents.CREATE_DECLARATION, context, reflection);
-        (0, signature_1.createSignature)(context.withScope(reflection), models_1.ReflectionKind.CallSignature, type.getCallSignatures()[0], type.getSymbol());
-        return new models_1.ReflectionType(reflection);
+        context.converter.trigger(ConverterEvents.CREATE_DECLARATION, context, reflection);
+        createSignature(context.withScope(reflection), ReflectionKind.CallSignature, type.getCallSignatures()[0], type.getSymbol());
+        return new ReflectionType(reflection);
     },
 };
 const importType = {
-    kind: [typescript_1.default.SyntaxKind.ImportType],
+    kind: [ts.SyntaxKind.ImportType],
     convert(context, node) {
         const name = node.qualifier?.getText() ?? "__module";
         const symbol = context.checker.getSymbolAtLocation(node);
-        (0, assert_1.default)(symbol, "Missing symbol when converting import type node");
-        return models_1.ReferenceType.createSymbolReference(context.resolveAliasedSymbol(symbol), context, name);
+        assert(symbol, "Missing symbol when converting import type node");
+        return ReferenceType.createSymbolReference(context.resolveAliasedSymbol(symbol), context, name);
     },
     convertType(context, type) {
         const symbol = type.getSymbol();
-        (0, assert_1.default)(symbol, "Missing symbol when converting import type"); // Should be a compiler error
-        return models_1.ReferenceType.createSymbolReference(context.resolveAliasedSymbol(symbol), context, "__module");
+        assert(symbol, "Missing symbol when converting import type"); // Should be a compiler error
+        return ReferenceType.createSymbolReference(context.resolveAliasedSymbol(symbol), context, "__module");
     },
 };
 const indexedAccessConverter = {
-    kind: [typescript_1.default.SyntaxKind.IndexedAccessType],
+    kind: [ts.SyntaxKind.IndexedAccessType],
     convert(context, node) {
-        return new models_1.IndexedAccessType(convertType(context, node.objectType), convertType(context, node.indexType));
+        return new IndexedAccessType(convertType(context, node.objectType), convertType(context, node.indexType));
     },
     convertType(context, type) {
-        return new models_1.IndexedAccessType(convertType(context, type.objectType), convertType(context, type.indexType));
+        return new IndexedAccessType(convertType(context, type.objectType), convertType(context, type.indexType));
     },
 };
 const inferredConverter = {
-    kind: [typescript_1.default.SyntaxKind.InferType],
+    kind: [ts.SyntaxKind.InferType],
     convert(context, node) {
-        return new models_1.InferredType(node.typeParameter.name.text, maybeConvertType(context, node.typeParameter.constraint));
+        return new InferredType(node.typeParameter.name.text, maybeConvertType(context, node.typeParameter.constraint));
     },
     convertType(context, type) {
-        return new models_1.InferredType(type.getSymbol().name, maybeConvertType(context, type.getConstraint()));
+        return new InferredType(type.getSymbol().name, maybeConvertType(context, type.getConstraint()));
     },
 };
 const intersectionConverter = {
-    kind: [typescript_1.default.SyntaxKind.IntersectionType],
+    kind: [ts.SyntaxKind.IntersectionType],
     convert(context, node) {
-        return new models_1.IntersectionType(node.types.map((type) => convertType(context, type)));
+        return new IntersectionType(node.types.map((type) => convertType(context, type)));
     },
     convertType(context, type) {
-        return new models_1.IntersectionType(type.types.map((type) => convertType(context, type)));
+        return new IntersectionType(type.types.map((type) => convertType(context, type)));
     },
 };
 const intrinsicConverter = {
-    kind: [typescript_1.default.SyntaxKind.IntrinsicKeyword],
+    kind: [ts.SyntaxKind.IntrinsicKeyword],
     convert() {
-        return new models_1.IntrinsicType("intrinsic");
+        return new IntrinsicType("intrinsic");
     },
     convertType() {
-        return new models_1.IntrinsicType("intrinsic");
+        return new IntrinsicType("intrinsic");
     },
 };
 const jsDocVariadicTypeConverter = {
-    kind: [typescript_1.default.SyntaxKind.JSDocVariadicType],
+    kind: [ts.SyntaxKind.JSDocVariadicType],
     convert(context, node) {
-        return new models_1.ArrayType(convertType(context, node.type));
+        return new ArrayType(convertType(context, node.type));
     },
     // Should just be an ArrayType
     convertType: requestBugReport,
 };
 const keywordNames = {
-    [typescript_1.default.SyntaxKind.AnyKeyword]: "any",
-    [typescript_1.default.SyntaxKind.BigIntKeyword]: "bigint",
-    [typescript_1.default.SyntaxKind.BooleanKeyword]: "boolean",
-    [typescript_1.default.SyntaxKind.NeverKeyword]: "never",
-    [typescript_1.default.SyntaxKind.NumberKeyword]: "number",
-    [typescript_1.default.SyntaxKind.ObjectKeyword]: "object",
-    [typescript_1.default.SyntaxKind.StringKeyword]: "string",
-    [typescript_1.default.SyntaxKind.SymbolKeyword]: "symbol",
-    [typescript_1.default.SyntaxKind.UndefinedKeyword]: "undefined",
-    [typescript_1.default.SyntaxKind.UnknownKeyword]: "unknown",
-    [typescript_1.default.SyntaxKind.VoidKeyword]: "void",
-    [typescript_1.default.SyntaxKind.IntrinsicKeyword]: "intrinsic",
+    [ts.SyntaxKind.AnyKeyword]: "any",
+    [ts.SyntaxKind.BigIntKeyword]: "bigint",
+    [ts.SyntaxKind.BooleanKeyword]: "boolean",
+    [ts.SyntaxKind.NeverKeyword]: "never",
+    [ts.SyntaxKind.NumberKeyword]: "number",
+    [ts.SyntaxKind.ObjectKeyword]: "object",
+    [ts.SyntaxKind.StringKeyword]: "string",
+    [ts.SyntaxKind.SymbolKeyword]: "symbol",
+    [ts.SyntaxKind.UndefinedKeyword]: "undefined",
+    [ts.SyntaxKind.UnknownKeyword]: "unknown",
+    [ts.SyntaxKind.VoidKeyword]: "void",
+    [ts.SyntaxKind.IntrinsicKeyword]: "intrinsic",
 };
 const keywordConverter = {
     kind: [
-        typescript_1.default.SyntaxKind.AnyKeyword,
-        typescript_1.default.SyntaxKind.BigIntKeyword,
-        typescript_1.default.SyntaxKind.BooleanKeyword,
-        typescript_1.default.SyntaxKind.NeverKeyword,
-        typescript_1.default.SyntaxKind.NumberKeyword,
-        typescript_1.default.SyntaxKind.ObjectKeyword,
-        typescript_1.default.SyntaxKind.StringKeyword,
-        typescript_1.default.SyntaxKind.SymbolKeyword,
-        typescript_1.default.SyntaxKind.UndefinedKeyword,
-        typescript_1.default.SyntaxKind.UnknownKeyword,
-        typescript_1.default.SyntaxKind.VoidKeyword,
+        ts.SyntaxKind.AnyKeyword,
+        ts.SyntaxKind.BigIntKeyword,
+        ts.SyntaxKind.BooleanKeyword,
+        ts.SyntaxKind.NeverKeyword,
+        ts.SyntaxKind.NumberKeyword,
+        ts.SyntaxKind.ObjectKeyword,
+        ts.SyntaxKind.StringKeyword,
+        ts.SyntaxKind.SymbolKeyword,
+        ts.SyntaxKind.UndefinedKeyword,
+        ts.SyntaxKind.UnknownKeyword,
+        ts.SyntaxKind.VoidKeyword,
     ],
     convert(_context, node) {
-        return new models_1.IntrinsicType(keywordNames[node.kind]);
+        return new IntrinsicType(keywordNames[node.kind]);
     },
     convertType(_context, _type, node) {
-        return new models_1.IntrinsicType(keywordNames[node.kind]);
+        return new IntrinsicType(keywordNames[node.kind]);
     },
 };
 const optionalConverter = {
-    kind: [typescript_1.default.SyntaxKind.OptionalType],
+    kind: [ts.SyntaxKind.OptionalType],
     convert(context, node) {
-        return new models_1.OptionalType((0, reflections_1.removeUndefined)(convertType(context, node.type)));
+        return new OptionalType(removeUndefined(convertType(context, node.type)));
     },
     // Handled by the tuple converter
     convertType: requestBugReport,
 };
 const parensConverter = {
-    kind: [typescript_1.default.SyntaxKind.ParenthesizedType],
+    kind: [ts.SyntaxKind.ParenthesizedType],
     convert(context, node) {
         return convertType(context, node.type);
     },
@@ -344,14 +337,14 @@ const parensConverter = {
     convertType: requestBugReport,
 };
 const predicateConverter = {
-    kind: [typescript_1.default.SyntaxKind.TypePredicate],
+    kind: [ts.SyntaxKind.TypePredicate],
     convert(context, node) {
-        const name = typescript_1.default.isThisTypeNode(node.parameterName)
+        const name = ts.isThisTypeNode(node.parameterName)
             ? "this"
             : node.parameterName.getText();
         const asserts = !!node.assertsModifier;
         const targetType = node.type ? convertType(context, node.type) : void 0;
-        return new models_1.PredicateType(name, asserts, targetType);
+        return new PredicateType(name, asserts, targetType);
     },
     // Never inferred by TS 4.0, could potentially change in a future TS version.
     convertType: requestBugReport,
@@ -359,85 +352,98 @@ const predicateConverter = {
 // This is a horrible thing... we're going to want to split this into converters
 // for different types at some point.
 const typeLiteralConverter = {
-    kind: [typescript_1.default.SyntaxKind.TypeLiteral],
+    kind: [ts.SyntaxKind.TypeLiteral],
     convert(context, node) {
         const symbol = context.getSymbolAtLocation(node) ?? node.symbol;
         const type = context.getTypeAtLocation(node);
         if (!symbol || !type) {
-            return new models_1.IntrinsicType("Object");
+            return new IntrinsicType("Object");
         }
-        const reflection = new models_1.DeclarationReflection("__type", models_1.ReflectionKind.TypeLiteral, context.scope);
+        const reflection = new DeclarationReflection("__type", ReflectionKind.TypeLiteral, context.scope);
         const rc = context.withScope(reflection);
         rc.convertingTypeNode = true;
         context.registerReflection(reflection, symbol);
-        context.converter.trigger(converter_events_1.ConverterEvents.CREATE_DECLARATION, context, reflection);
+        context.converter.trigger(ConverterEvents.CREATE_DECLARATION, context, reflection);
         for (const prop of context.checker.getPropertiesOfType(type)) {
-            (0, symbols_1.convertSymbol)(rc, prop);
+            convertSymbol(rc, prop);
         }
         for (const signature of type.getCallSignatures()) {
-            (0, signature_1.createSignature)(rc, models_1.ReflectionKind.CallSignature, signature, symbol);
+            createSignature(rc, ReflectionKind.CallSignature, signature, symbol);
         }
         for (const signature of type.getConstructSignatures()) {
-            (0, signature_1.createSignature)(rc, models_1.ReflectionKind.ConstructorSignature, signature, symbol);
+            createSignature(rc, ReflectionKind.ConstructorSignature, signature, symbol);
         }
-        (0, index_signature_1.convertIndexSignatures)(rc, symbol);
-        return new models_1.ReflectionType(reflection);
+        convertIndexSignatures(rc, type);
+        return new ReflectionType(reflection);
     },
     convertType(context, type) {
         const symbol = type.getSymbol();
-        const reflection = new models_1.DeclarationReflection("__type", models_1.ReflectionKind.TypeLiteral, context.scope);
+        const reflection = new DeclarationReflection("__type", ReflectionKind.TypeLiteral, context.scope);
         context.registerReflection(reflection, symbol);
-        context.converter.trigger(converter_events_1.ConverterEvents.CREATE_DECLARATION, context, reflection);
+        context.converter.trigger(ConverterEvents.CREATE_DECLARATION, context, reflection);
         for (const prop of context.checker.getPropertiesOfType(type)) {
-            (0, symbols_1.convertSymbol)(context.withScope(reflection), prop);
+            convertSymbol(context.withScope(reflection), prop);
         }
         for (const signature of type.getCallSignatures()) {
-            (0, signature_1.createSignature)(context.withScope(reflection), models_1.ReflectionKind.CallSignature, signature, symbol);
+            createSignature(context.withScope(reflection), ReflectionKind.CallSignature, signature, symbol);
         }
         for (const signature of type.getConstructSignatures()) {
-            (0, signature_1.createSignature)(context.withScope(reflection), models_1.ReflectionKind.ConstructorSignature, signature, symbol);
+            createSignature(context.withScope(reflection), ReflectionKind.ConstructorSignature, signature, symbol);
         }
         if (symbol) {
-            (0, index_signature_1.convertIndexSignatures)(context.withScope(reflection), symbol);
+            convertIndexSignatures(context.withScope(reflection), type);
         }
-        return new models_1.ReflectionType(reflection);
+        return new ReflectionType(reflection);
     },
 };
 const queryConverter = {
-    kind: [typescript_1.default.SyntaxKind.TypeQuery],
+    kind: [ts.SyntaxKind.TypeQuery],
     convert(context, node) {
         const querySymbol = context.getSymbolAtLocation(node.exprName);
         if (!querySymbol) {
             // This can happen if someone uses `typeof` on some property
             // on a variable typed as `any` with a name that doesn't exist.
-            return new models_1.QueryType(models_1.ReferenceType.createBrokenReference(node.exprName.getText(), context.project));
+            return new QueryType(ReferenceType.createBrokenReference(node.exprName.getText(), context.project));
         }
-        const ref = models_1.ReferenceType.createSymbolReference(context.resolveAliasedSymbol(querySymbol), context, node.exprName.getText());
+        const ref = ReferenceType.createSymbolReference(context.resolveAliasedSymbol(querySymbol), context, node.exprName.getText());
         ref.preferValues = true;
-        return new models_1.QueryType(ref);
+        return new QueryType(ref);
     },
     convertType(context, type, node) {
         // Order matters here - check the node location first so that if the typeof is targeting
         // an instantiation expression we get the user's exprName.
         const symbol = context.getSymbolAtLocation(node.exprName) || type.getSymbol();
-        (0, assert_1.default)(symbol, `Query type failed to get a symbol for: ${context.checker.typeToString(type)}. This is a bug.`);
-        const ref = models_1.ReferenceType.createSymbolReference(context.resolveAliasedSymbol(symbol), context);
+        assert(symbol, `Query type failed to get a symbol for: ${context.checker.typeToString(type)}. This is a bug.`);
+        const ref = ReferenceType.createSymbolReference(context.resolveAliasedSymbol(symbol), context);
         ref.preferValues = true;
-        return new models_1.QueryType(ref);
+        return new QueryType(ref);
     },
 };
 const referenceConverter = {
-    kind: [typescript_1.default.SyntaxKind.TypeReference],
+    kind: [ts.SyntaxKind.TypeReference],
     convert(context, node) {
-        const isArray = context.checker.typeToTypeNode(context.checker.getTypeAtLocation(node.typeName), void 0, typescript_1.default.NodeBuilderFlags.IgnoreErrors)?.kind === typescript_1.default.SyntaxKind.ArrayType;
+        const type = context.checker.getTypeAtLocation(node.typeName);
+        const isArray = context.checker.typeToTypeNode(type, void 0, ts.NodeBuilderFlags.IgnoreErrors)?.kind === ts.SyntaxKind.ArrayType;
         if (isArray) {
-            return new models_1.ArrayType(convertType(context, node.typeArguments?.[0]));
+            return new ArrayType(convertType(context, node.typeArguments?.[0]));
         }
         const symbol = context.expectSymbolAtLocation(node.typeName);
+        // Ignore @inline if there are type arguments, as they won't be resolved
+        // in the type we just retrieved from node.typeName.
+        if (!node.typeArguments &&
+            context
+                .getComment(symbol, ReflectionKind.Interface)
+                ?.hasModifier("@inline")) {
+            // typeLiteralConverter doesn't use the node, so we can get away with lying here.
+            // This might not actually be safe, it appears that it is in the relatively small
+            // amount of testing I've done with it, but I wouldn't be surprised if someone manages
+            // to find a crash.
+            return typeLiteralConverter.convertType(context, type, null);
+        }
         const name = node.typeName.getText();
-        const type = models_1.ReferenceType.createSymbolReference(context.resolveAliasedSymbol(symbol), context, name);
-        type.typeArguments = node.typeArguments?.map((type) => convertType(context, type));
-        return type;
+        const ref = ReferenceType.createSymbolReference(context.resolveAliasedSymbol(symbol), context, name);
+        ref.typeArguments = node.typeArguments?.map((type) => convertType(context, type));
+        return ref;
     },
     convertType(context, type, node) {
         // typeName.symbol handles the case where this is a union which happens to refer
@@ -447,25 +453,34 @@ const referenceConverter = {
         if (!symbol) {
             // This happens when we get a reference to a type parameter
             // created within a mapped type, `K` in: `{ [K in T]: string }`
-            const ref = models_1.ReferenceType.createBrokenReference(context.checker.typeToString(type), context.project);
+            const ref = ReferenceType.createBrokenReference(context.checker.typeToString(type), context.project);
             ref.refersToTypeParameter = true;
             return ref;
         }
+        if (context
+            .getComment(symbol, ReflectionKind.Interface)
+            ?.hasModifier("@inline")) {
+            // typeLiteralConverter doesn't use the node, so we can get away with lying here.
+            // This might not actually be safe, it appears that it is in the relatively small
+            // amount of testing I've done with it, but I wouldn't be surprised if someone manages
+            // to find a crash.
+            return typeLiteralConverter.convertType(context, type, null);
+        }
         let name;
-        if (typescript_1.default.isIdentifier(node.typeName)) {
+        if (ts.isIdentifier(node.typeName)) {
             name = node.typeName.text;
         }
         else {
             name = node.typeName.right.text;
         }
-        const ref = models_1.ReferenceType.createSymbolReference(context.resolveAliasedSymbol(symbol), context, name);
-        if (type.flags & typescript_1.default.TypeFlags.Substitution) {
+        const ref = ReferenceType.createSymbolReference(context.resolveAliasedSymbol(symbol), context, name);
+        if (type.flags & ts.TypeFlags.Substitution) {
             // NoInfer<T>
             ref.typeArguments = [
                 convertType(context, type.baseType),
             ];
         }
-        else if (type.flags & typescript_1.default.TypeFlags.StringMapping) {
+        else if (type.flags & ts.TypeFlags.StringMapping) {
             ref.typeArguments = [
                 convertType(context, type.type),
             ];
@@ -479,18 +494,18 @@ const referenceConverter = {
     },
 };
 const restConverter = {
-    kind: [typescript_1.default.SyntaxKind.RestType],
+    kind: [ts.SyntaxKind.RestType],
     convert(context, node) {
-        return new models_1.RestType(convertType(context, node.type));
+        return new RestType(convertType(context, node.type));
     },
     // This is handled in the tuple converter
     convertType: requestBugReport,
 };
 const namedTupleMemberConverter = {
-    kind: [typescript_1.default.SyntaxKind.NamedTupleMember],
+    kind: [ts.SyntaxKind.NamedTupleMember],
     convert(context, node) {
         const innerType = convertType(context, node.type);
-        return new models_1.NamedTupleMember(node.name.getText(), !!node.questionToken, innerType);
+        return new NamedTupleMember(node.name.getText(), !!node.questionToken, innerType);
     },
     // This ought to be impossible.
     convertType: requestBugReport,
@@ -502,103 +517,103 @@ const namedTupleMemberConverter = {
 //                          ^ questionToken
 //                              ^^^^^^ type
 const mappedConverter = {
-    kind: [typescript_1.default.SyntaxKind.MappedType],
+    kind: [ts.SyntaxKind.MappedType],
     convert(context, node) {
         const optionalModifier = kindToModifier(node.questionToken?.kind);
         const templateType = convertType(context, node.type);
-        return new models_1.MappedType(node.typeParameter.name.text, convertType(context, node.typeParameter.constraint), optionalModifier === "+"
-            ? (0, reflections_1.removeUndefined)(templateType)
+        return new MappedType(node.typeParameter.name.text, convertType(context, node.typeParameter.constraint), optionalModifier === "+"
+            ? removeUndefined(templateType)
             : templateType, kindToModifier(node.readonlyToken?.kind), optionalModifier, node.nameType ? convertType(context, node.nameType) : void 0);
     },
     convertType(context, type, node) {
         // This can happen if a generic function does not have a return type annotated.
         const optionalModifier = kindToModifier(node.questionToken?.kind);
         const templateType = convertType(context, type.templateType);
-        return new models_1.MappedType(type.typeParameter.symbol.name || "__type", convertType(context, type.typeParameter.getConstraint()), optionalModifier === "+"
-            ? (0, reflections_1.removeUndefined)(templateType)
+        return new MappedType(type.typeParameter.symbol.name || "__type", convertType(context, type.typeParameter.getConstraint()), optionalModifier === "+"
+            ? removeUndefined(templateType)
             : templateType, kindToModifier(node.readonlyToken?.kind), optionalModifier, type.nameType ? convertType(context, type.nameType) : void 0);
     },
 };
 const literalTypeConverter = {
-    kind: [typescript_1.default.SyntaxKind.LiteralType],
+    kind: [ts.SyntaxKind.LiteralType],
     convert(context, node) {
         switch (node.literal.kind) {
-            case typescript_1.default.SyntaxKind.TrueKeyword:
-            case typescript_1.default.SyntaxKind.FalseKeyword:
-                return new models_1.LiteralType(node.literal.kind === typescript_1.default.SyntaxKind.TrueKeyword);
-            case typescript_1.default.SyntaxKind.StringLiteral:
-                return new models_1.LiteralType(node.literal.text);
-            case typescript_1.default.SyntaxKind.NumericLiteral:
-                return new models_1.LiteralType(Number(node.literal.text));
-            case typescript_1.default.SyntaxKind.NullKeyword:
-                return new models_1.LiteralType(null);
-            case typescript_1.default.SyntaxKind.PrefixUnaryExpression: {
+            case ts.SyntaxKind.TrueKeyword:
+            case ts.SyntaxKind.FalseKeyword:
+                return new LiteralType(node.literal.kind === ts.SyntaxKind.TrueKeyword);
+            case ts.SyntaxKind.StringLiteral:
+                return new LiteralType(node.literal.text);
+            case ts.SyntaxKind.NumericLiteral:
+                return new LiteralType(Number(node.literal.text));
+            case ts.SyntaxKind.NullKeyword:
+                return new LiteralType(null);
+            case ts.SyntaxKind.PrefixUnaryExpression: {
                 const operand = node.literal
                     .operand;
                 switch (operand.kind) {
-                    case typescript_1.default.SyntaxKind.NumericLiteral:
-                        return new models_1.LiteralType(Number(node.literal.getText()));
-                    case typescript_1.default.SyntaxKind.BigIntLiteral:
-                        return new models_1.LiteralType(BigInt(node.literal.getText().replace("n", "")));
+                    case ts.SyntaxKind.NumericLiteral:
+                        return new LiteralType(Number(node.literal.getText()));
+                    case ts.SyntaxKind.BigIntLiteral:
+                        return new LiteralType(BigInt(node.literal.getText().replace("n", "")));
                     default:
                         return requestBugReport(context, node.literal);
                 }
             }
-            case typescript_1.default.SyntaxKind.BigIntLiteral:
-                return new models_1.LiteralType(BigInt(node.literal.getText().replace("n", "")));
-            case typescript_1.default.SyntaxKind.NoSubstitutionTemplateLiteral:
-                return new models_1.LiteralType(node.literal.text);
+            case ts.SyntaxKind.BigIntLiteral:
+                return new LiteralType(BigInt(node.literal.getText().replace("n", "")));
+            case ts.SyntaxKind.NoSubstitutionTemplateLiteral:
+                return new LiteralType(node.literal.text);
         }
         return requestBugReport(context, node.literal);
     },
     convertType(_context, type, node) {
         switch (node.literal.kind) {
-            case typescript_1.default.SyntaxKind.StringLiteral:
-                return new models_1.LiteralType(node.literal.text);
-            case typescript_1.default.SyntaxKind.NumericLiteral:
-                return new models_1.LiteralType(+node.literal.text);
-            case typescript_1.default.SyntaxKind.TrueKeyword:
-            case typescript_1.default.SyntaxKind.FalseKeyword:
-                return new models_1.LiteralType(node.literal.kind === typescript_1.default.SyntaxKind.TrueKeyword);
-            case typescript_1.default.SyntaxKind.NullKeyword:
-                return new models_1.LiteralType(null);
+            case ts.SyntaxKind.StringLiteral:
+                return new LiteralType(node.literal.text);
+            case ts.SyntaxKind.NumericLiteral:
+                return new LiteralType(+node.literal.text);
+            case ts.SyntaxKind.TrueKeyword:
+            case ts.SyntaxKind.FalseKeyword:
+                return new LiteralType(node.literal.kind === ts.SyntaxKind.TrueKeyword);
+            case ts.SyntaxKind.NullKeyword:
+                return new LiteralType(null);
         }
         if (typeof type.value === "object") {
-            return new models_1.LiteralType(BigInt(`${type.value.negative ? "-" : ""}${type.value.base10Value}`));
+            return new LiteralType(BigInt(`${type.value.negative ? "-" : ""}${type.value.base10Value}`));
         }
-        return new models_1.LiteralType(type.value);
+        return new LiteralType(type.value);
     },
 };
 const templateLiteralConverter = {
-    kind: [typescript_1.default.SyntaxKind.TemplateLiteralType],
+    kind: [ts.SyntaxKind.TemplateLiteralType],
     convert(context, node) {
-        return new models_1.TemplateLiteralType(node.head.text, node.templateSpans.map((span) => {
+        return new TemplateLiteralType(node.head.text, node.templateSpans.map((span) => {
             return [convertType(context, span.type), span.literal.text];
         }));
     },
     convertType(context, type) {
-        (0, assert_1.default)(type.texts.length === type.types.length + 1);
+        assert(type.texts.length === type.types.length + 1);
         const parts = [];
-        for (const [a, b] of (0, array_1.zip)(type.types, type.texts.slice(1))) {
+        for (const [a, b] of zip(type.types, type.texts.slice(1))) {
             parts.push([convertType(context, a), b]);
         }
-        return new models_1.TemplateLiteralType(type.texts[0], parts);
+        return new TemplateLiteralType(type.texts[0], parts);
     },
 };
 const thisConverter = {
-    kind: [typescript_1.default.SyntaxKind.ThisType],
+    kind: [ts.SyntaxKind.ThisType],
     convert() {
-        return new models_1.IntrinsicType("this");
+        return new IntrinsicType("this");
     },
     convertType() {
-        return new models_1.IntrinsicType("this");
+        return new IntrinsicType("this");
     },
 };
 const tupleConverter = {
-    kind: [typescript_1.default.SyntaxKind.TupleType],
+    kind: [ts.SyntaxKind.TupleType],
     convert(context, node) {
         const elements = node.elements.map((node) => convertType(context, node));
-        return new models_1.TupleType(elements);
+        return new TupleType(elements);
     },
     convertType(context, type, node) {
         const types = type.typeArguments?.slice(0, node.elements.length);
@@ -608,56 +623,56 @@ const tupleConverter = {
             elements = elements?.map((el, i) => {
                 const namedDecl = namedDeclarations[i];
                 return namedDecl
-                    ? new models_1.NamedTupleMember(namedDecl.name.getText(), !!namedDecl.questionToken, (0, reflections_1.removeUndefined)(el))
+                    ? new NamedTupleMember(namedDecl.name.getText(), !!namedDecl.questionToken, removeUndefined(el))
                     : el;
             });
         }
         elements = elements?.map((el, i) => {
-            if (type.target.elementFlags[i] & typescript_1.default.ElementFlags.Variable) {
+            if (type.target.elementFlags[i] & ts.ElementFlags.Variable) {
                 // In the node case, we don't need to add the wrapping Array type... but we do here.
-                if (el instanceof models_1.NamedTupleMember) {
-                    return new models_1.RestType(new models_1.NamedTupleMember(el.name, el.isOptional, new models_1.ArrayType(el.element)));
+                if (el instanceof NamedTupleMember) {
+                    return new RestType(new NamedTupleMember(el.name, el.isOptional, new ArrayType(el.element)));
                 }
-                return new models_1.RestType(new models_1.ArrayType(el));
+                return new RestType(new ArrayType(el));
             }
-            if (type.target.elementFlags[i] & typescript_1.default.ElementFlags.Optional &&
-                !(el instanceof models_1.NamedTupleMember)) {
-                return new models_1.OptionalType((0, reflections_1.removeUndefined)(el));
+            if (type.target.elementFlags[i] & ts.ElementFlags.Optional &&
+                !(el instanceof NamedTupleMember)) {
+                return new OptionalType(removeUndefined(el));
             }
             return el;
         });
-        return new models_1.TupleType(elements ?? []);
+        return new TupleType(elements ?? []);
     },
 };
 const supportedOperatorNames = {
-    [typescript_1.default.SyntaxKind.KeyOfKeyword]: "keyof",
-    [typescript_1.default.SyntaxKind.UniqueKeyword]: "unique",
-    [typescript_1.default.SyntaxKind.ReadonlyKeyword]: "readonly",
+    [ts.SyntaxKind.KeyOfKeyword]: "keyof",
+    [ts.SyntaxKind.UniqueKeyword]: "unique",
+    [ts.SyntaxKind.ReadonlyKeyword]: "readonly",
 };
 const typeOperatorConverter = {
-    kind: [typescript_1.default.SyntaxKind.TypeOperator],
+    kind: [ts.SyntaxKind.TypeOperator],
     convert(context, node) {
-        return new models_1.TypeOperatorType(convertType(context, node.type), supportedOperatorNames[node.operator]);
+        return new TypeOperatorType(convertType(context, node.type), supportedOperatorNames[node.operator]);
     },
     convertType(context, type, node) {
         // readonly is only valid on array and tuple literal types.
-        if (node.operator === typescript_1.default.SyntaxKind.ReadonlyKeyword) {
+        if (node.operator === ts.SyntaxKind.ReadonlyKeyword) {
             const resolved = resolveReference(type);
-            (0, assert_1.default)((0, nodes_1.isObjectType)(resolved));
+            assert(isObjectType(resolved));
             const args = context.checker
                 .getTypeArguments(type)
                 .map((type) => convertType(context, type));
-            const inner = resolved.objectFlags & typescript_1.default.ObjectFlags.Tuple
-                ? new models_1.TupleType(args)
-                : new models_1.ArrayType(args[0]);
-            return new models_1.TypeOperatorType(inner, "readonly");
+            const inner = resolved.objectFlags & ts.ObjectFlags.Tuple
+                ? new TupleType(args)
+                : new ArrayType(args[0]);
+            return new TypeOperatorType(inner, "readonly");
         }
         // keyof will only show up with generic functions, otherwise it gets eagerly
         // resolved to a union of strings.
-        if (node.operator === typescript_1.default.SyntaxKind.KeyOfKeyword) {
+        if (node.operator === ts.SyntaxKind.KeyOfKeyword) {
             // There's probably an interface for this somewhere... I couldn't find it.
             const targetType = type.type;
-            return new models_1.TypeOperatorType(convertType(context, targetType), "keyof");
+            return new TypeOperatorType(convertType(context, targetType), "keyof");
         }
         // TS drops `unique` in `unique symbol` everywhere. If someone used it, we ought
         // to have a type node. This shouldn't ever happen.
@@ -665,30 +680,30 @@ const typeOperatorConverter = {
     },
 };
 const unionConverter = {
-    kind: [typescript_1.default.SyntaxKind.UnionType],
+    kind: [ts.SyntaxKind.UnionType],
     convert(context, node) {
-        return new models_1.UnionType(node.types.map((type) => convertType(context, type)));
+        return new UnionType(node.types.map((type) => convertType(context, type)));
     },
     convertType(context, type) {
         const types = type.types.map((type) => convertType(context, type));
         normalizeUnion(types);
         sortLiteralUnion(types);
-        return new models_1.UnionType(types);
+        return new UnionType(types);
     },
 };
 const jsDocNullableTypeConverter = {
-    kind: [typescript_1.default.SyntaxKind.JSDocNullableType],
+    kind: [ts.SyntaxKind.JSDocNullableType],
     convert(context, node) {
-        return new models_1.UnionType([
+        return new UnionType([
             convertType(context, node.type),
-            new models_1.LiteralType(null),
+            new LiteralType(null),
         ]);
     },
     // Should be a UnionType
     convertType: requestBugReport,
 };
 const jsDocNonNullableTypeConverter = {
-    kind: [typescript_1.default.SyntaxKind.JSDocNonNullableType],
+    kind: [ts.SyntaxKind.JSDocNonNullableType],
     convert(context, node) {
         return convertType(context, node.type);
     },
@@ -697,29 +712,29 @@ const jsDocNonNullableTypeConverter = {
 };
 function requestBugReport(context, nodeOrType) {
     if ("kind" in nodeOrType) {
-        const kindName = typescript_1.default.SyntaxKind[nodeOrType.kind];
+        const kindName = ts.SyntaxKind[nodeOrType.kind];
         context.logger.warn(`Failed to convert type node with kind: ${kindName} and text ${nodeOrType.getText()}. Please report a bug.`, nodeOrType);
-        return new models_1.UnknownType(nodeOrType.getText());
+        return new UnknownType(nodeOrType.getText());
     }
     else {
         const typeString = context.checker.typeToString(nodeOrType);
         context.logger.warn(`Failed to convert type: ${typeString} when converting ${context.scope.getFullName()}. Please report a bug.`);
-        return new models_1.UnknownType(typeString);
+        return new UnknownType(typeString);
     }
 }
 function resolveReference(type) {
-    if ((0, nodes_1.isObjectType)(type) && type.objectFlags & typescript_1.default.ObjectFlags.Reference) {
+    if (isObjectType(type) && type.objectFlags & ts.ObjectFlags.Reference) {
         return type.target;
     }
     return type;
 }
 function kindToModifier(kind) {
     switch (kind) {
-        case typescript_1.default.SyntaxKind.ReadonlyKeyword:
-        case typescript_1.default.SyntaxKind.QuestionToken:
-        case typescript_1.default.SyntaxKind.PlusToken:
+        case ts.SyntaxKind.ReadonlyKeyword:
+        case ts.SyntaxKind.QuestionToken:
+        case ts.SyntaxKind.PlusToken:
             return "+";
-        case typescript_1.default.SyntaxKind.MinusToken:
+        case ts.SyntaxKind.MinusToken:
             return "-";
         default:
             return undefined;
@@ -740,7 +755,7 @@ function normalizeUnion(types) {
     let falseIndex = -1;
     for (let i = 0; i < types.length && (trueIndex === -1 || falseIndex === -1); i++) {
         const t = types[i];
-        if (t instanceof models_1.LiteralType) {
+        if (t instanceof LiteralType) {
             if (t.value === true) {
                 trueIndex = i;
             }
@@ -751,6 +766,6 @@ function normalizeUnion(types) {
     }
     if (trueIndex !== -1 && falseIndex !== -1) {
         types.splice(Math.max(trueIndex, falseIndex), 1);
-        types.splice(Math.min(trueIndex, falseIndex), 1, new models_1.IntrinsicType("boolean"));
+        types.splice(Math.min(trueIndex, falseIndex), 1, new IntrinsicType("boolean"));
     }
 }