typedoc 0.26.11 → 0.27.0-beta.1

package/dist/lib/models/types.js

@@ -1,49 +1,23 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UnknownType = exports.UnionType = exports.TypeOperatorType = exports.NamedTupleMember = exports.TupleType = exports.TemplateLiteralType = exports.RestType = exports.ReflectionType = exports.ReferenceType = exports.QueryType = exports.PredicateType = exports.OptionalType = exports.MappedType = exports.LiteralType = exports.IntrinsicType = exports.IntersectionType = exports.InferredType = exports.IndexedAccessType = exports.ConditionalType = exports.ArrayType = exports.TypeContext = exports.Type = void 0;
-exports.makeRecursiveVisitor = makeRecursiveVisitor;
-const ts = __importStar(require("typescript"));
-const tsutils_1 = require("../utils/tsutils");
-const ReflectionSymbolId_1 = require("./reflections/ReflectionSymbolId");
-const fs_1 = require("../utils/fs");
-const kind_1 = require("./reflections/kind");
-const comments_1 = require("./comments");
+import * as ts from "typescript";
+import { getQualifiedName } from "../utils/tsutils.js";
+import { ReflectionSymbolId } from "./reflections/ReflectionSymbolId.js";
+import { findPackageForPath } from "../utils/fs.js";
+import { ReflectionKind } from "./reflections/kind.js";
+import { Comment } from "./comments/index.js";
+import { joinArray } from "../utils/array.js";
 /**
  * Base class of all type definitions.
  * @category Types
  */
-class Type {
+export class Type {
     /**
      * Return a string representation of this type.
      */
     toString() {
-        return this.stringify(exports.TypeContext.none);
+        return this.stringify(TypeContext.none);
     }
-    visit(visitor) {
-        return visitor[this.type]?.(this);
+    visit(visitor, ...args) {
+        return visitor[this.type]?.(this, ...args);
     }
     stringify(context) {
         if (this.needsParenthesis(context)) {
@@ -53,9 +27,14 @@ class Type {
     }
     // Nothing to do for the majority of types.
     fromObject(_de, _obj) { }
+    /**
+     * Return the estimated size of the type if it was all printed on one line.
+     */
+    estimatePrintWidth() {
+        return this.getTypeString().length;
+    }
 }
-exports.Type = Type;
-function makeRecursiveVisitor(visitor) {
+export function makeRecursiveVisitor(visitor) {
     const recursiveVisitor = {
         namedTupleMember(type) {
             visitor.namedTupleMember?.(type);
@@ -151,7 +130,7 @@ function makeRecursiveVisitor(visitor) {
  * Used by TypeDoc internally to track when to output parenthesis when rendering.
  * @enum
  */
-exports.TypeContext = {
+export const TypeContext = {
     none: "none",
     templateLiteralElement: "templateLiteralElement", // `${here}`
     arrayElement: "arrayElement", // here[]
@@ -184,17 +163,18 @@ exports.TypeContext = {
  * ```
  * @category Types
  */
-class ArrayType extends Type {
+export class ArrayType extends Type {
+    elementType;
+    type = "array";
     /**
      * @param elementType The type of the elements in the array.
      */
     constructor(elementType) {
         super();
         this.elementType = elementType;
-        this.type = "array";
     }
     getTypeString() {
-        return this.elementType.stringify(exports.TypeContext.arrayElement) + "[]";
+        return this.elementType.stringify(TypeContext.arrayElement) + "[]";
     }
     needsParenthesis() {
         return false;
@@ -206,7 +186,6 @@ class ArrayType extends Type {
         };
     }
 }
-exports.ArrayType = ArrayType;
 /**
  * Represents a conditional type.
  *
@@ -215,24 +194,28 @@ exports.ArrayType = ArrayType;
  * ```
  * @category Types
  */
-class ConditionalType extends Type {
+export class ConditionalType extends Type {
+    checkType;
+    extendsType;
+    trueType;
+    falseType;
+    type = "conditional";
     constructor(checkType, extendsType, trueType, falseType) {
         super();
         this.checkType = checkType;
         this.extendsType = extendsType;
         this.trueType = trueType;
         this.falseType = falseType;
-        this.type = "conditional";
     }
     getTypeString() {
         return [
-            this.checkType.stringify(exports.TypeContext.conditionalCheck),
+            this.checkType.stringify(TypeContext.conditionalCheck),
             "extends",
-            this.extendsType.stringify(exports.TypeContext.conditionalExtends),
+            this.extendsType.stringify(TypeContext.conditionalExtends),
             "?",
-            this.trueType.stringify(exports.TypeContext.conditionalTrue),
+            this.trueType.stringify(TypeContext.conditionalTrue),
             ":",
-            this.falseType.stringify(exports.TypeContext.conditionalFalse),
+            this.falseType.stringify(TypeContext.conditionalFalse),
         ].join(" ");
     }
     needsParenthesis(context) {
@@ -273,23 +256,24 @@ class ConditionalType extends Type {
         };
     }
 }
-exports.ConditionalType = ConditionalType;
 /**
  * Represents an indexed access type.
  * @category Types
  */
-class IndexedAccessType extends Type {
+export class IndexedAccessType extends Type {
+    objectType;
+    indexType;
+    type = "indexedAccess";
     constructor(objectType, indexType) {
         super();
         this.objectType = objectType;
         this.indexType = indexType;
-        this.type = "indexedAccess";
     }
     getTypeString() {
         return [
-            this.objectType.stringify(exports.TypeContext.indexedObject),
+            this.objectType.stringify(TypeContext.indexedObject),
             "[",
-            this.indexType.stringify(exports.TypeContext.indexedIndex),
+            this.indexType.stringify(TypeContext.indexedIndex),
             "]",
         ].join("");
     }
@@ -304,7 +288,6 @@ class IndexedAccessType extends Type {
         };
     }
 }
-exports.IndexedAccessType = IndexedAccessType;
 /**
  * Represents an inferred type, U in the example below.
  *
@@ -313,16 +296,18 @@ exports.IndexedAccessType = IndexedAccessType;
  * ```
  * @category Types
  */
-class InferredType extends Type {
+export class InferredType extends Type {
+    name;
+    constraint;
+    type = "inferred";
     constructor(name, constraint) {
         super();
         this.name = name;
         this.constraint = constraint;
-        this.type = "inferred";
     }
     getTypeString() {
         if (this.constraint) {
-            return `infer ${this.name} extends ${this.constraint.stringify(exports.TypeContext.inferredConstraint)}`;
+            return `infer ${this.name} extends ${this.constraint.stringify(TypeContext.inferredConstraint)}`;
         }
         return `infer ${this.name}`;
     }
@@ -362,7 +347,6 @@ class InferredType extends Type {
         };
     }
 }
-exports.InferredType = InferredType;
 /**
  * Represents an intersection type.
  *
@@ -371,15 +355,16 @@ exports.InferredType = InferredType;
  * ```
  * @category Types
  */
-class IntersectionType extends Type {
+export class IntersectionType extends Type {
+    types;
+    type = "intersection";
     constructor(types) {
         super();
         this.types = types;
-        this.type = "intersection";
     }
     getTypeString() {
         return this.types
-            .map((t) => t.stringify(exports.TypeContext.intersectionElement))
+            .map((t) => t.stringify(TypeContext.intersectionElement))
             .join(" & ");
     }
     needsParenthesis(context) {
@@ -417,7 +402,6 @@ class IntersectionType extends Type {
         };
     }
 }
-exports.IntersectionType = IntersectionType;
 /**
  * Represents an intrinsic type like `string` or `boolean`.
  *
@@ -426,11 +410,12 @@ exports.IntersectionType = IntersectionType;
  * ```
  * @category Types
  */
-class IntrinsicType extends Type {
+export class IntrinsicType extends Type {
+    name;
+    type = "intrinsic";
     constructor(name) {
         super();
         this.name = name;
-        this.type = "intrinsic";
     }
     getTypeString() {
         return this.name;
@@ -445,7 +430,6 @@ class IntrinsicType extends Type {
         return false;
     }
 }
-exports.IntrinsicType = IntrinsicType;
 /**
  * Represents a literal type.
  *
@@ -455,11 +439,12 @@ exports.IntrinsicType = IntrinsicType;
  * ```
  * @category Types
  */
-class LiteralType extends Type {
+export class LiteralType extends Type {
+    value;
+    type = "literal";
     constructor(value) {
         super();
         this.value = value;
-        this.type = "literal";
     }
     /**
      * Return a string representation of this type.
@@ -489,7 +474,6 @@ class LiteralType extends Type {
         };
     }
 }
-exports.LiteralType = LiteralType;
 /**
  * Represents a mapped type.
  *
@@ -498,7 +482,14 @@ exports.LiteralType = LiteralType;
  * ```
  * @category Types
  */
-class MappedType extends Type {
+export class MappedType extends Type {
+    parameter;
+    parameterType;
+    templateType;
+    readonlyModifier;
+    optionalModifier;
+    nameType;
+    type = "mapped";
     constructor(parameter, parameterType, templateType, readonlyModifier, optionalModifier, nameType) {
         super();
         this.parameter = parameter;
@@ -507,7 +498,6 @@ class MappedType extends Type {
         this.readonlyModifier = readonlyModifier;
         this.optionalModifier = optionalModifier;
         this.nameType = nameType;
-        this.type = "mapped";
     }
     getTypeString() {
         const read = {
@@ -526,12 +516,12 @@ class MappedType extends Type {
             "[",
             this.parameter,
             " in ",
-            this.parameterType.stringify(exports.TypeContext.mappedParameter),
+            this.parameterType.stringify(TypeContext.mappedParameter),
         ];
         if (this.nameType) {
-            parts.push(" as ", this.nameType.stringify(exports.TypeContext.mappedName));
+            parts.push(" as ", this.nameType.stringify(TypeContext.mappedName));
         }
-        parts.push("]", opt, ": ", this.templateType.stringify(exports.TypeContext.mappedTemplate), " }");
+        parts.push("]", opt, ": ", this.templateType.stringify(TypeContext.mappedTemplate), " }");
         return parts.join("");
     }
     needsParenthesis() {
@@ -549,7 +539,6 @@ class MappedType extends Type {
         };
     }
 }
-exports.MappedType = MappedType;
 /**
  * Represents an optional type
  * ```ts
@@ -558,14 +547,15 @@ exports.MappedType = MappedType;
  * ```
  * @category Types
  */
-class OptionalType extends Type {
+export class OptionalType extends Type {
+    elementType;
+    type = "optional";
     constructor(elementType) {
         super();
         this.elementType = elementType;
-        this.type = "optional";
     }
     getTypeString() {
-        return this.elementType.stringify(exports.TypeContext.optionalElement) + "?";
+        return this.elementType.stringify(TypeContext.optionalElement) + "?";
     }
     needsParenthesis() {
         return false;
@@ -577,7 +567,6 @@ class OptionalType extends Type {
         };
     }
 }
-exports.OptionalType = OptionalType;
 /**
  * Represents a type predicate.
  *
@@ -587,7 +576,11 @@ exports.OptionalType = OptionalType;
  * ```
  * @category Types
  */
-class PredicateType extends Type {
+export class PredicateType extends Type {
+    name;
+    asserts;
+    targetType;
+    type = "predicate";
     /**
      * Create a new PredicateType instance.
      *
@@ -603,7 +596,6 @@ class PredicateType extends Type {
         this.name = name;
         this.asserts = asserts;
         this.targetType = targetType;
-        this.type = "predicate";
     }
     /**
      * Return a string representation of this type.
@@ -611,7 +603,7 @@ class PredicateType extends Type {
     getTypeString() {
         const out = this.asserts ? ["asserts", this.name] : [this.name];
         if (this.targetType) {
-            out.push("is", this.targetType.stringify(exports.TypeContext.predicateTarget));
+            out.push("is", this.targetType.stringify(TypeContext.predicateTarget));
         }
         return out.join(" ");
     }
@@ -627,7 +619,6 @@ class PredicateType extends Type {
         };
     }
 }
-exports.PredicateType = PredicateType;
 /**
  * Represents a type that is constructed by querying the type of a reflection.
  * ```ts
@@ -636,14 +627,15 @@ exports.PredicateType = PredicateType;
  * ```
  * @category Types
  */
-class QueryType extends Type {
+export class QueryType extends Type {
+    queryType;
+    type = "query";
     constructor(queryType) {
         super();
         this.queryType = queryType;
-        this.type = "query";
     }
     getTypeString() {
-        return `typeof ${this.queryType.stringify(exports.TypeContext.queryTypeTarget)}`;
+        return `typeof ${this.queryType.stringify(TypeContext.queryTypeTarget)}`;
     }
     /**
      * @privateRemarks
@@ -661,7 +653,6 @@ class QueryType extends Type {
         };
     }
 }
-exports.QueryType = QueryType;
 /**
  * Represents a type that refers to another reflection like a class, interface or enum.
  *
@@ -670,7 +661,19 @@ exports.QueryType = QueryType;
  * ```
  * @category Types
  */
-class ReferenceType extends Type {
+export class ReferenceType extends Type {
+    type = "reference";
+    /**
+     * The name of the referenced type.
+     *
+     * If the symbol cannot be found because it's not part of the documentation this
+     * can be used to represent the type.
+     */
+    name;
+    /**
+     * The type arguments of this reference.
+     */
+    typeArguments;
     /**
      * The resolved reflection.
      */
@@ -683,13 +686,22 @@ class ReferenceType extends Type {
             return;
         }
         const kind = this.preferValues
-            ? kind_1.ReflectionKind.ValueReferenceTarget
-            : kind_1.ReflectionKind.TypeReferenceTarget;
+            ? ReflectionKind.ValueReferenceTarget
+            : ReflectionKind.TypeReferenceTarget;
         const resolved = resolvePotential.find((refl) => refl.kindOf(kind)) ||
             resolvePotential.find((refl) => refl.kindOf(~kind));
         this._target = resolved.id;
         return resolved;
     }
+    /**
+     * Sometimes a few properties are more important than the rest
+     * of the properties within a type. This occurs most often with
+     * object parameters, where users want to specify `@param foo.bar`
+     * to highlight something about the `bar` property.
+     *
+     * Does NOT support nested properties.
+     */
+    highlightedProperties;
     /**
      * If not resolved, the symbol id of the reflection, otherwise undefined.
      */
@@ -703,6 +715,10 @@ class ReferenceType extends Type {
      * to a reflection. This happens for type parameters and when representing a mapped type.
      */
     isIntentionallyBroken() {
+        if (typeof this._target === "object" &&
+            this._project?.symbolIdHasBeenRemoved(this._target)) {
+            return true;
+        }
         return this._target === -1 || this.refersToTypeParameter;
     }
     /**
@@ -719,20 +735,35 @@ class ReferenceType extends Type {
             },
         };
     }
+    /**
+     * The fully qualified name of the referenced type, relative to the file it is defined in.
+     * This will usually be the same as `name`, unless namespaces are used.
+     */
+    qualifiedName;
+    /**
+     * The package that this type is referencing.
+     */
+    package;
+    /**
+     * If this reference type refers to a reflection defined by a project not being rendered,
+     * points to the url that this type should be linked to.
+     */
+    externalUrl;
+    /**
+     * If set, no warnings about something not being exported should be created
+     * since this may be referring to a type created with `infer X` which will not
+     * be registered on the project.
+     */
+    refersToTypeParameter = false;
+    /**
+     * If set, will prefer reflections with {@link ReflectionKind | ReflectionKinds} which represent
+     * values rather than those which represent types.
+     */
+    preferValues = false;
+    _target;
+    _project;
     constructor(name, target, project, qualifiedName) {
         super();
-        this.type = "reference";
-        /**
-         * If set, no warnings about something not being exported should be created
-         * since this may be referring to a type created with `infer X` which will not
-         * be registered on the project.
-         */
-        this.refersToTypeParameter = false;
-        /**
-         * If set, will prefer reflections with {@link ReflectionKind | ReflectionKinds} which represent
-         * values rather than those which represent types.
-         */
-        this.preferValues = false;
         this.name = name;
         if (typeof target === "number") {
             this._target = target;
@@ -747,14 +778,14 @@ class ReferenceType extends Type {
         return new ReferenceType(name, target, project, name);
     }
     static createSymbolReference(symbol, context, name) {
-        const ref = new ReferenceType(name ?? symbol.name, new ReflectionSymbolId_1.ReflectionSymbolId(symbol), context.project, (0, tsutils_1.getQualifiedName)(symbol, name ?? symbol.name));
+        const ref = new ReferenceType(name ?? symbol.name, new ReflectionSymbolId(symbol), context.project, getQualifiedName(symbol, name ?? symbol.name));
         ref.refersToTypeParameter = !!(symbol.flags & ts.SymbolFlags.TypeParameter);
         const symbolPath = symbol.declarations?.[0]
             ?.getSourceFile()
             .fileName.replace(/\\/g, "/");
         if (!symbolPath)
             return ref;
-        ref.package = (0, fs_1.findPackageForPath)(symbolPath);
+        ref.package = findPackageForPath(symbolPath);
         return ref;
     }
     /**
@@ -772,7 +803,7 @@ class ReferenceType extends Type {
         if (this.typeArguments && this.typeArguments.length > 0) {
             typeArgs += "<";
             typeArgs += this.typeArguments
-                .map((arg) => arg.stringify(exports.TypeContext.referenceTypeArgument))
+                .map((arg) => arg.stringify(TypeContext.referenceTypeArgument))
                 .join(", ");
             typeArgs += ">";
         }
@@ -782,11 +813,19 @@ class ReferenceType extends Type {
         return false;
     }
     toObject(serializer) {
+        let target;
+        if (typeof this._target === "number") {
+            target = this._target;
+        }
+        else if (this._project?.symbolIdHasBeenRemoved(this._target)) {
+            target = -1;
+        }
+        else {
+            target = this._target.toObject(serializer);
+        }
         const result = {
             type: this.type,
-            target: typeof this._target === "number"
-                ? this._target
-                : this._target.toObject(serializer),
+            target,
             typeArguments: serializer.toObjectsOptional(this.typeArguments),
             name: this.name,
             package: this.package,
@@ -801,6 +840,14 @@ class ReferenceType extends Type {
         if (typeof this._target !== "number" && this.preferValues) {
             result.preferValues = true;
         }
+        if (this.highlightedProperties) {
+            result.highlightedProperties = Object.fromEntries(Array.from(this.highlightedProperties.entries(), ([key, parts]) => {
+                return [
+                    key,
+                    Comment.serializeDisplayParts(serializer, parts),
+                ];
+            }));
+        }
         return result;
     }
     fromObject(de, obj) {
@@ -822,15 +869,20 @@ class ReferenceType extends Type {
         }
         else {
             this._project = de.project;
-            this._target = new ReflectionSymbolId_1.ReflectionSymbolId(obj.target);
+            this._target = new ReflectionSymbolId(obj.target);
         }
         this.qualifiedName = obj.qualifiedName ?? obj.name;
         this.package = obj.package;
         this.refersToTypeParameter = !!obj.refersToTypeParameter;
         this.preferValues = !!obj.preferValues;
+        if (obj.highlightedProperties) {
+            this.highlightedProperties = new Map();
+            for (const [key, parts] of Object.entries(obj.highlightedProperties)) {
+                this.highlightedProperties.set(key, Comment.deserializeDisplayParts(de, parts));
+            }
+        }
     }
 }
-exports.ReferenceType = ReferenceType;
 /**
  * Represents a type which has it's own reflection like literal types.
  * This type will likely go away at some point and be replaced by a dedicated
@@ -842,22 +894,32 @@ exports.ReferenceType = ReferenceType;
  * ```
  * @category Types
  */
-class ReflectionType extends Type {
+export class ReflectionType extends Type {
+    declaration;
+    type = "reflection";
     constructor(declaration) {
         super();
         this.declaration = declaration;
-        this.type = "reflection";
     }
-    // This really ought to do better, but I'm putting off investing effort here until
-    // I'm fully convinced that keeping this is a good idea. Currently, I'd much rather
-    // change object types to not create reflections.
     getTypeString() {
-        if (!this.declaration.children && this.declaration.signatures) {
-            return "Function";
+        const parts = [];
+        const sigs = this.declaration.getAllSignatures();
+        for (const sig of sigs) {
+            parts.push(sigStr(sig, ": "));
         }
-        else {
-            return "Object";
+        if (this.declaration.children) {
+            for (const p of this.declaration.children) {
+                parts.push(`${p.name}${propertySep(p)} ${typeStr(p.type)}`);
+            }
+            return `{ ${parts.join("; ")} }`;
         }
+        if (sigs.length === 1) {
+            return sigStr(sigs[0], " => ");
+        }
+        if (parts.length === 0) {
+            return "{}";
+        }
+        return `{ ${parts.join("; ")} }`;
     }
     needsParenthesis() {
         return false;
@@ -869,7 +931,6 @@ class ReflectionType extends Type {
         };
     }
 }
-exports.ReflectionType = ReflectionType;
 /**
  * Represents a rest type
  * ```ts
@@ -878,14 +939,15 @@ exports.ReflectionType = ReflectionType;
  * ```
  * @category Types
  */
-class RestType extends Type {
+export class RestType extends Type {
+    elementType;
+    type = "rest";
     constructor(elementType) {
         super();
         this.elementType = elementType;
-        this.type = "rest";
     }
     getTypeString() {
-        return `...${this.elementType.stringify(exports.TypeContext.restElement)}`;
+        return `...${this.elementType.stringify(TypeContext.restElement)}`;
     }
     needsParenthesis() {
         return false;
@@ -897,7 +959,6 @@ class RestType extends Type {
         };
     }
 }
-exports.RestType = RestType;
 /**
  * TS 4.1 template literal types
  * ```ts
@@ -905,12 +966,14 @@ exports.RestType = RestType;
  * ```
  * @category Types
  */
-class TemplateLiteralType extends Type {
+export class TemplateLiteralType extends Type {
+    head;
+    tail;
+    type = "templateLiteral";
     constructor(head, tail) {
         super();
         this.head = head;
         this.tail = tail;
-        this.type = "templateLiteral";
     }
     getTypeString() {
         return [
@@ -918,7 +981,7 @@ class TemplateLiteralType extends Type {
             this.head,
             ...this.tail.map(([type, text]) => {
                 return ("${" +
-                    type.stringify(exports.TypeContext.templateLiteralElement) +
+                    type.stringify(TypeContext.templateLiteralElement) +
                     "}" +
                     text);
             }),
@@ -939,7 +1002,6 @@ class TemplateLiteralType extends Type {
         };
     }
 }
-exports.TemplateLiteralType = TemplateLiteralType;
 /**
  * Represents a tuple type.
  *
@@ -948,19 +1010,20 @@ exports.TemplateLiteralType = TemplateLiteralType;
  * ```
  * @category Types
  */
-class TupleType extends Type {
+export class TupleType extends Type {
+    elements;
+    type = "tuple";
     /**
      * @param elements The ordered type elements of the tuple type.
      */
     constructor(elements) {
         super();
         this.elements = elements;
-        this.type = "tuple";
     }
     getTypeString() {
         return ("[" +
             this.elements
-                .map((t) => t.stringify(exports.TypeContext.tupleElement))
+                .map((t) => t.stringify(TypeContext.tupleElement))
                 .join(", ") +
             "]");
     }
@@ -974,7 +1037,6 @@ class TupleType extends Type {
         };
     }
 }
-exports.TupleType = TupleType;
 /**
  * Represents a named member of a tuple type.
  *
@@ -983,19 +1045,22 @@ exports.TupleType = TupleType;
  * ```
  * @category Types
  */
-class NamedTupleMember extends Type {
+export class NamedTupleMember extends Type {
+    name;
+    isOptional;
+    element;
+    type = "namedTupleMember";
     constructor(name, isOptional, element) {
         super();
         this.name = name;
         this.isOptional = isOptional;
         this.element = element;
-        this.type = "namedTupleMember";
     }
     /**
      * Return a string representation of this type.
      */
     getTypeString() {
-        return `${this.name}${this.isOptional ? "?" : ""}: ${this.element.stringify(exports.TypeContext.tupleElement)}`;
+        return `${this.name}${this.isOptional ? "?" : ""}: ${this.element.stringify(TypeContext.tupleElement)}`;
     }
     needsParenthesis() {
         return false;
@@ -1009,7 +1074,6 @@ class NamedTupleMember extends Type {
         };
     }
 }
-exports.NamedTupleMember = NamedTupleMember;
 /**
  * Represents a type operator type.
  *
@@ -1019,15 +1083,17 @@ exports.NamedTupleMember = NamedTupleMember;
  * ```
  * @category Types
  */
-class TypeOperatorType extends Type {
+export class TypeOperatorType extends Type {
+    target;
+    operator;
+    type = "typeOperator";
     constructor(target, operator) {
         super();
         this.target = target;
         this.operator = operator;
-        this.type = "typeOperator";
     }
     getTypeString() {
-        return `${this.operator} ${this.target.stringify(exports.TypeContext.typeOperatorTarget)}`;
+        return `${this.operator} ${this.target.stringify(TypeContext.typeOperatorTarget)}`;
     }
     needsParenthesis(context) {
         const map = {
@@ -1065,7 +1131,6 @@ class TypeOperatorType extends Type {
         };
     }
 }
-exports.TypeOperatorType = TypeOperatorType;
 /**
  * Represents an union type.
  *
@@ -1074,15 +1139,23 @@ exports.TypeOperatorType = TypeOperatorType;
  * ```
  * @category Types
  */
-class UnionType extends Type {
+export class UnionType extends Type {
+    types;
+    type = "union";
+    /**
+     * If present, there should be as many items in this array as there are items in the {@link types} array.
+     *
+     * This member is only valid on unions which are on {@link DeclarationReflection.type | DeclarationReflection.type} with a
+     * {@link ReflectionKind} `kind` of `TypeAlias`. Specifying it on any other union is undefined behavior.
+     */
+    elementSummaries;
     constructor(types) {
         super();
         this.types = types;
-        this.type = "union";
     }
     getTypeString() {
         return this.types
-            .map((t) => t.stringify(exports.TypeContext.unionElement))
+            .map((t) => t.stringify(TypeContext.unionElement))
             .join(" | ");
     }
     needsParenthesis(context) {
@@ -1115,26 +1188,29 @@ class UnionType extends Type {
     }
     fromObject(de, obj) {
         if (obj.elementSummaries) {
-            this.elementSummaries = obj.elementSummaries.map((parts) => comments_1.Comment.deserializeDisplayParts(de, parts));
+            this.elementSummaries = obj.elementSummaries.map((parts) => Comment.deserializeDisplayParts(de, parts));
         }
     }
     toObject(serializer) {
         return {
             type: this.type,
             types: this.types.map((t) => serializer.toObject(t)),
-            elementSummaries: this.elementSummaries?.map((parts) => comments_1.Comment.serializeDisplayParts(serializer, parts)),
+            elementSummaries: this.elementSummaries?.map((parts) => Comment.serializeDisplayParts(serializer, parts)),
         };
     }
 }
-exports.UnionType = UnionType;
 /**
  * Represents all unknown types that cannot be converted by TypeDoc.
  * @category Types
  */
-class UnknownType extends Type {
+export class UnknownType extends Type {
+    type = "unknown";
+    /**
+     * A string representation of the type as returned from TypeScript compiler.
+     */
+    name;
     constructor(name) {
         super();
-        this.type = "unknown";
         this.name = name;
     }
     getTypeString() {
@@ -1145,7 +1221,7 @@ class UnknownType extends Type {
      * to be extra safe.
      */
     needsParenthesis(context) {
-        return context !== exports.TypeContext.none;
+        return context !== TypeContext.none;
     }
     toObject() {
         return {
@@ -1154,4 +1230,13 @@ class UnknownType extends Type {
         };
     }
 }
-exports.UnknownType = UnknownType;
+function propertySep(refl) {
+    return refl.flags.isOptional ? "?:" : ":";
+}
+function typeStr(type) {
+    return type?.toString() ?? "any";
+}
+function sigStr(sig, sep) {
+    const params = joinArray(sig.parameters, ", ", (p) => `${p.name}${propertySep(p)} ${typeStr(p.type)}`);
+    return `(${params})${sep}${typeStr(sig.type)}`;
+}