typedoc 0.23.13 → 0.23.15

package/dist/index.d.ts

@@ -3,7 +3,7 @@ export { EventDispatcher, Event } from "./lib/utils/events";
 export { resetReflectionID } from "./lib/models/reflections/abstract";
 export { normalizePath } from "./lib/utils/fs";
 export * from "./lib/models";
-export { Converter, Context, type CommentParserConfig } from "./lib/converter";
+export { Converter, Context, type CommentParserConfig, type DeclarationReference, type SymbolReference, type ComponentPath, type Meaning, type MeaningKeyword, } from "./lib/converter";
 export { Renderer, DefaultTheme, DefaultThemeRenderContext, UrlMapping, Theme, PageEvent, RendererEvent, MarkdownEvent, IndexEvent, } from "./lib/output";
 export type { RenderTemplate, RendererHooks } from "./lib/output";
 export { ArgumentsReader, BindOption, CommentStyle, JSX, LogLevel, Logger, Options, ParameterHint, ParameterType, TSConfigReader, TypeDocReader, EntryPointStrategy, EventHooks, MinimalSourceFile, } from "./lib/utils";

package/dist/lib/converter/comments/linkResolver.d.ts

@@ -1,4 +1,5 @@
 import { Comment, CommentDisplayPart, Reflection } from "../../models";
 import type { Logger, ValidationOptions } from "../../utils";
-export declare function resolveLinks(comment: Comment, reflection: Reflection, validation: ValidationOptions, logger: Logger): void;
-export declare function resolvePartLinks(reflection: Reflection, parts: readonly CommentDisplayPart[], warn: () => void, validation: ValidationOptions, logger: Logger): CommentDisplayPart[];
+import { DeclarationReference } from "./declarationReference";
+export declare function resolveLinks(comment: Comment, reflection: Reflection, validation: ValidationOptions, logger: Logger, attemptExternalResolve: (ref: DeclarationReference) => string | undefined): void;
+export declare function resolvePartLinks(reflection: Reflection, parts: readonly CommentDisplayPart[], warn: () => void, validation: ValidationOptions, logger: Logger, attemptExternalResolve: (ref: DeclarationReference) => string | undefined): CommentDisplayPart[];

package/dist/lib/converter/comments/linkResolver.js

@@ -7,7 +7,7 @@ const declarationReference_1 = require("./declarationReference");
 const declarationReferenceResolver_1 = require("./declarationReferenceResolver");
 const urlPrefix = /^(http|ftp)s?:\/\//;
 const brackets = /\[\[(?!include:)([^\]]+)\]\]/g;
-function resolveLinks(comment, reflection, validation, logger) {
+function resolveLinks(comment, reflection, validation, logger, attemptExternalResolve) {
     let warned = false;
     const warn = () => {
         if (!warned) {
@@ -15,20 +15,20 @@ function resolveLinks(comment, reflection, validation, logger) {
             logger.warn(`${reflection.getFriendlyFullName()}: Comment [[target]] style links are deprecated and will be removed in 0.24`);
         }
     };
-    comment.summary = resolvePartLinks(reflection, comment.summary, warn, validation, logger);
+    comment.summary = resolvePartLinks(reflection, comment.summary, warn, validation, logger, attemptExternalResolve);
     for (const tag of comment.blockTags) {
-        tag.content = resolvePartLinks(reflection, tag.content, warn, validation, logger);
+        tag.content = resolvePartLinks(reflection, tag.content, warn, validation, logger, attemptExternalResolve);
     }
     if (reflection instanceof models_1.DeclarationReflection && reflection.readme) {
-        reflection.readme = resolvePartLinks(reflection, reflection.readme, warn, validation, logger);
+        reflection.readme = resolvePartLinks(reflection, reflection.readme, warn, validation, logger, attemptExternalResolve);
     }
 }
 exports.resolveLinks = resolveLinks;
-function resolvePartLinks(reflection, parts, warn, validation, logger) {
-    return parts.flatMap((part) => processPart(reflection, part, warn, validation, logger));
+function resolvePartLinks(reflection, parts, warn, validation, logger, attemptExternalResolve) {
+    return parts.flatMap((part) => processPart(reflection, part, warn, validation, logger, attemptExternalResolve));
 }
 exports.resolvePartLinks = resolvePartLinks;
-function processPart(reflection, part, warn, validation, logger) {
+function processPart(reflection, part, warn, validation, logger, attemptExternalResolve) {
     if (part.kind === "text" && brackets.test(part.text)) {
         warn();
         return replaceBrackets(reflection, part.text, validation, logger);
@@ -37,7 +37,7 @@ function processPart(reflection, part, warn, validation, logger) {
         if (part.tag === "@link" ||
             part.tag === "@linkcode" ||
             part.tag === "@linkplain") {
-            return resolveLinkTag(reflection, part, (msg) => {
+            return resolveLinkTag(reflection, part, attemptExternalResolve, (msg) => {
                 if (validation.invalidLink) {
                     logger.warn(msg);
                 }
@@ -46,7 +46,7 @@ function processPart(reflection, part, warn, validation, logger) {
     }
     return part;
 }
-function resolveLinkTag(reflection, part, warn) {
+function resolveLinkTag(reflection, part, attemptExternalResolve, warn) {
     let pos = 0;
     const end = part.text.length;
     while (pos < end && ts.isWhiteSpaceLike(part.text.charCodeAt(pos))) {
@@ -56,10 +56,21 @@ function resolveLinkTag(reflection, part, warn) {
     // Try to parse one
     const declRef = (0, declarationReference_1.parseDeclarationReference)(part.text, pos, end);
     let target;
+    let defaultDisplayText;
     if (declRef) {
         // Got one, great! Try to resolve the link
         target = (0, declarationReferenceResolver_1.resolveDeclarationReference)(reflection, declRef[0]);
         pos = declRef[1];
+        if (target) {
+            defaultDisplayText = target.name;
+        }
+        else {
+            // If we didn't find a link, it might be a @link tag to an external symbol, check that next.
+            target = attemptExternalResolve(declRef[0]);
+            if (target) {
+                defaultDisplayText = part.text.substring(0, pos);
+            }
+        }
     }
     if (!target) {
         if (urlPrefix.test(part.text)) {
@@ -67,13 +78,14 @@ function resolveLinkTag(reflection, part, warn) {
             target =
                 wsIndex === -1 ? part.text : part.text.substring(0, wsIndex);
             pos = target.length;
+            defaultDisplayText = target;
         }
     }
     // If resolution via a declaration reference failed, revert to the legacy "split and check"
     // method... this should go away in 0.24, once people have had a chance to migrate any failing links.
     if (!target) {
         const resolved = legacyResolveLinkTag(reflection, part);
-        if (resolved) {
+        if (resolved.target) {
             warn(`Failed to resolve {@link ${origText}} in ${reflection.getFriendlyFullName()} with declaration references. This link will break in v0.24.`);
         }
         return resolved;
@@ -87,9 +99,7 @@ function resolveLinkTag(reflection, part, warn) {
         pos++;
     }
     part.target = target;
-    part.text =
-        part.text.substring(pos).trim() ||
-            (typeof target === "string" ? target : target.name);
+    part.text = part.text.substring(pos).trim() || defaultDisplayText;
     return part;
 }
 function legacyResolveLinkTag(reflection, part) {

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

@@ -8,25 +8,31 @@ import { MinimalSourceFile } from "../utils";
 import type { DocumentationEntryPoint } from "../utils/entry-point";
 import { CommentParserConfig } from "./comments";
 import type { CommentStyle, ValidationOptions } from "../utils/options/declaration";
+import type { DeclarationReference } from "./comments/declarationReference";
 /**
  * Compiles source files using TypeScript and converts compiler symbols to reflections.
  */
 export declare class Converter extends ChildableComponent<Application, ConverterComponent> {
-    /**
-     * The human readable name of the project. Used within the templates to set the title of the document.
-     */
-    name: string;
+    /** @internal */
     externalPattern: string[];
     private externalPatternCache?;
     private excludeCache?;
+    /** @internal */
     excludeExternals: boolean;
+    /** @internal */
     excludeNotDocumented: boolean;
+    /** @internal */
     excludePrivate: boolean;
+    /** @internal */
     excludeProtected: boolean;
+    /** @internal */
     commentStyle: CommentStyle;
     /** @internal */
     validation: ValidationOptions;
+    /** @internal */
+    externalSymbolLinkMappings: Record<string, Record<string, string>>;
     private _config?;
+    private _externalSymbolResolvers;
     get config(): CommentParserConfig;
     /**
      * General events
@@ -92,12 +98,13 @@ export declare class Converter extends ChildableComponent<Application, Converter
      * @event
      */
     static readonly EVENT_RESOLVE_END: "resolveEnd";
+    constructor(owner: Application);
     /**
      * Compile the given source files and create a project reflection for them.
      */
     convert(entryPoints: readonly DocumentationEntryPoint[]): ProjectReflection;
     /** @internal */
-    convertSymbol(context: Context, symbol: ts.Symbol): void;
+    convertSymbol(context: Context, symbol: ts.Symbol, exportSymbol?: ts.Symbol): void;
     /**
      * Convert the given TypeScript type into its TypeDoc type reflection.
      *
@@ -111,6 +118,21 @@ export declare class Converter extends ChildableComponent<Application, Converter
      * Parse the given file into a comment. Intended to be used with markdown files.
      */
     parseRawComment(file: MinimalSourceFile): Comment;
+    /**
+     * Adds a new resolver that the theme can use to try to figure out how to link to a symbol declared
+     * by a third-party library which is not included in the documentation.
+     *
+     * The resolver function will be passed a declaration reference which it can attempt to resolve. If
+     * resolution fails, the function should return undefined.
+     *
+     * Note: This will be used for both references to types declared in node_modules (in which case the
+     * reference passed will have the `moduleSource` set and the `symbolReference` will navigate via `.`)
+     * and user defined \{\@link\} tags which cannot be resolved.
+     * @since 0.22.14
+     */
+    addUnknownSymbolResolver(resolver: (ref: DeclarationReference) => string | undefined): void;
+    /** @internal */
+    resolveExternalLink(ref: DeclarationReference): string | undefined;
     resolveLinks(comment: Comment, owner: Reflection): void;
     resolveLinks(parts: readonly CommentDisplayPart[], owner: Reflection): CommentDisplayPart[];
     /**

package/dist/lib/converter/converter.js

@@ -27,6 +27,31 @@ const linkResolver_1 = require("./comments/linkResolver");
  * Compiles source files using TypeScript and converts compiler symbols to reflections.
  */
 let Converter = Converter_1 = class Converter extends component_1.ChildableComponent {
+    constructor(owner) {
+        super(owner);
+        this._externalSymbolResolvers = [];
+        this.addUnknownSymbolResolver((ref) => {
+            // Require global links, matching local ones will likely hide mistakes where the
+            // user meant to link to a local type.
+            if (ref.resolutionStart !== "global" || !ref.symbolReference) {
+                return;
+            }
+            const modLinks = this.externalSymbolLinkMappings[ref.moduleSource ?? "global"];
+            if (typeof modLinks !== "object") {
+                return;
+            }
+            let name = "";
+            if (ref.symbolReference.path) {
+                name += ref.symbolReference.path.map((p) => p.path).join(".");
+            }
+            if (ref.symbolReference.meaning) {
+                name += ":" + ref.symbolReference.meaning;
+            }
+            if (typeof modLinks[name] === "string") {
+                return modLinks[name];
+            }
+        });
+    }
     get config() {
         return this._config || this._buildCommentParserConfig();
     }
@@ -36,7 +61,7 @@ let Converter = Converter_1 = class Converter extends component_1.ChildableCompo
     convert(entryPoints) {
         const programs = entryPoints.map((e) => e.program);
         this.externalPatternCache = void 0;
-        const project = new index_1.ProjectReflection(this.name);
+        const project = new index_1.ProjectReflection(this.application.options.getValue("name"));
         const context = new context_1.Context(this, programs, project);
         this.trigger(Converter_1.EVENT_BEGIN, context);
         this.compile(entryPoints, context);
@@ -47,8 +72,8 @@ let Converter = Converter_1 = class Converter extends component_1.ChildableCompo
         return project;
     }
     /** @internal */
-    convertSymbol(context, symbol) {
-        (0, symbols_1.convertSymbol)(context, symbol);
+    convertSymbol(context, symbol, exportSymbol) {
+        (0, symbols_1.convertSymbol)(context, symbol, exportSymbol);
     }
     /**
      * Convert the given TypeScript type into its TypeDoc type reflection.
@@ -67,9 +92,32 @@ let Converter = Converter_1 = class Converter extends component_1.ChildableCompo
     parseRawComment(file) {
         return (0, parser_1.parseComment)((0, rawLexer_1.lexCommentString)(file.text), this.config, file, this.application.logger);
     }
+    /**
+     * Adds a new resolver that the theme can use to try to figure out how to link to a symbol declared
+     * by a third-party library which is not included in the documentation.
+     *
+     * The resolver function will be passed a declaration reference which it can attempt to resolve. If
+     * resolution fails, the function should return undefined.
+     *
+     * Note: This will be used for both references to types declared in node_modules (in which case the
+     * reference passed will have the `moduleSource` set and the `symbolReference` will navigate via `.`)
+     * and user defined \{\@link\} tags which cannot be resolved.
+     * @since 0.22.14
+     */
+    addUnknownSymbolResolver(resolver) {
+        this._externalSymbolResolvers.push(resolver);
+    }
+    /** @internal */
+    resolveExternalLink(ref) {
+        for (const resolver of this._externalSymbolResolvers) {
+            const resolved = resolver(ref);
+            if (resolved)
+                return resolved;
+        }
+    }
     resolveLinks(comment, owner) {
         if (comment instanceof index_1.Comment) {
-            (0, linkResolver_1.resolveLinks)(comment, owner, this.validation, this.owner.logger);
+            (0, linkResolver_1.resolveLinks)(comment, owner, this.validation, this.owner.logger, (ref) => this.resolveExternalLink(ref));
         }
         else {
             let warned = false;
@@ -79,7 +127,7 @@ let Converter = Converter_1 = class Converter extends component_1.ChildableCompo
                     this.application.logger.warn(`${owner.name}: Comment [[target]] style links are deprecated and will be removed in 0.24`);
                 }
             };
-            return (0, linkResolver_1.resolvePartLinks)(owner, comment, warn, this.validation, this.owner.logger);
+            return (0, linkResolver_1.resolvePartLinks)(owner, comment, warn, this.validation, this.owner.logger, (ref) => this.resolveExternalLink(ref));
         }
     }
     /**
@@ -262,9 +310,6 @@ Converter.EVENT_RESOLVE = converter_events_1.ConverterEvents.RESOLVE;
  * @event
  */
 Converter.EVENT_RESOLVE_END = converter_events_1.ConverterEvents.RESOLVE_END;
-__decorate([
-    (0, utils_1.BindOption)("name")
-], Converter.prototype, "name", void 0);
 __decorate([
     (0, utils_1.BindOption)("externalPattern")
 ], Converter.prototype, "externalPattern", void 0);
@@ -286,6 +331,9 @@ __decorate([
 __decorate([
     (0, utils_1.BindOption)("validation")
 ], Converter.prototype, "validation", void 0);
+__decorate([
+    (0, utils_1.BindOption)("externalSymbolLinkMappings")
+], Converter.prototype, "externalSymbolLinkMappings", void 0);
 Converter = Converter_1 = __decorate([
     (0, component_1.Component)({
         name: "converter",

package/dist/lib/converter/factories/signature.js

@@ -15,7 +15,12 @@ function createSignature(context, kind, signature, declaration) {
     const sigRef = new models_1.SignatureReflection(kind == models_1.ReflectionKind.ConstructorSignature
         ? `new ${context.scope.parent.name}`
         : context.scope.name, kind, context.scope);
-    if (declaration) {
+    // If we are creating signatures for a variable and the variable has a comment associated with it
+    // then we should prefer that variable's comment over any comment on the signature. The comment plugin
+    // will copy the comment down if this signature doesn't have one, so don't set one.
+    if (declaration &&
+        (!context.scope.comment ||
+            !(context.scope.conversionFlags & models_1.ConversionFlags.VariableSource))) {
         sigRef.comment = (0, comments_1.getSignatureComment)(declaration, context.converter.config, context.logger, context.converter.commentStyle);
     }
     sigRef.typeParameters = convertTypeParameters(context, sigRef, signature.typeParameters);

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

@@ -2,4 +2,5 @@ export { Context } from "./context";
 export { Converter } from "./converter";
 export type { CommentParserConfig } from "./comments/index";
 export { convertDefaultValue, convertExpression } from "./convert-expression";
+export type { DeclarationReference, SymbolReference, ComponentPath, Meaning, MeaningKeyword, } from "./comments/declarationReference";
 import "./plugins/index";

package/dist/lib/converter/jsdoc.js

@@ -16,6 +16,14 @@ function convertJsDocAlias(context, symbol, declaration, exportSymbol) {
         convertJsDocInterface(context, declaration, symbol, exportSymbol);
         return;
     }
+    // If the typedef tag is just referring to another type-space symbol, with no type parameters
+    // or appropriate forwarding type parameters, then we treat it as a re-export instead of creating
+    // a type alias with an import type.
+    const aliasedSymbol = getTypedefReExportTarget(context, declaration);
+    if (aliasedSymbol) {
+        context.converter.convertSymbol(context, aliasedSymbol, exportSymbol ?? symbol);
+        return;
+    }
     const reflection = context.createDeclarationReflection(models_1.ReflectionKind.TypeAlias, symbol, exportSymbol);
     reflection.comment = (0, comments_1.getJsDocComment)(declaration, context.converter.config, context.logger);
     reflection.type = context.converter.convertType(context.withScope(reflection), declaration.typeExpression?.type);
@@ -69,3 +77,36 @@ function convertTemplateParameterNodes(context, nodes) {
     const params = (nodes ?? []).flatMap((tag) => tag.typeParameters);
     return (0, signature_1.convertTypeParameterNodes)(context, params);
 }
+function getTypedefReExportTarget(context, declaration) {
+    const typeExpression = declaration.typeExpression;
+    if (!ts.isJSDocTypedefTag(declaration) ||
+        !typeExpression ||
+        ts.isJSDocTypeLiteral(typeExpression) ||
+        !ts.isImportTypeNode(typeExpression.type) ||
+        !typeExpression.type.qualifier ||
+        !ts.isIdentifier(typeExpression.type.qualifier)) {
+        return;
+    }
+    const targetSymbol = context.expectSymbolAtLocation(typeExpression.type.qualifier);
+    const decl = targetSymbol.declarations?.[0];
+    if (!decl ||
+        !(ts.isTypeAliasDeclaration(decl) ||
+            ts.isInterfaceDeclaration(decl) ||
+            ts.isJSDocTypedefTag(decl) ||
+            ts.isJSDocCallbackTag(decl))) {
+        return;
+    }
+    const targetParams = ts.getEffectiveTypeParameterDeclarations(decl);
+    const localParams = ts.getEffectiveTypeParameterDeclarations(declaration);
+    const localArgs = typeExpression.type.typeArguments || [];
+    // If we have type parameters, ensure they are forwarding parameters with no transformations.
+    // This doesn't check constraints since they aren't checked in JSDoc types.
+    if (targetParams.length !== localParams.length ||
+        localArgs.some((arg, i) => !ts.isTypeReferenceNode(arg) ||
+            !ts.isIdentifier(arg.typeName) ||
+            arg.typeArguments ||
+            localParams[i]?.name.text !== arg.typeName.text)) {
+        return;
+    }
+    return targetSymbol;
+}

package/dist/lib/converter/plugins/LinkResolverPlugin.js

@@ -11,6 +11,7 @@ const components_1 = require("../components");
 const converter_events_1 = require("../converter-events");
 const utils_1 = require("../../utils");
 const models_1 = require("../../models");
+const reflections_1 = require("../../utils/reflections");
 /**
  * A plugin that resolves `{@link Foo}` tags.
  */
@@ -35,6 +36,11 @@ let LinkResolverPlugin = class LinkResolverPlugin extends components_1.Converter
         if (context.project.readme) {
             context.project.readme = context.converter.resolveLinks(context.project.readme, context.project);
         }
+        for (const { type } of (0, reflections_1.discoverAllReferenceTypes)(context.project, false)) {
+            if (!type.reflection) {
+                type.externalUrl = context.converter.resolveExternalLink(type.toDeclarationReference());
+            }
+        }
     }
 };
 __decorate([

package/dist/lib/converter/symbols.js

@@ -477,6 +477,7 @@ function convertVariableAsFunction(context, symbol, exportSymbol) {
         : context.checker.getDeclaredTypeOfSymbol(symbol);
     const reflection = context.createDeclarationReflection(models_1.ReflectionKind.Function, symbol, exportSymbol);
     setModifiers(symbol, accessDeclaration, reflection);
+    reflection.conversionFlags |= models_1.ConversionFlags.VariableSource;
     context.finalizeDeclarationReflection(reflection);
     const reflectionContext = context.withScope(reflection);
     reflection.signatures ?? (reflection.signatures = []);

package/dist/lib/converter/types.js

@@ -9,6 +9,7 @@ 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");
 const converters = new Map();
 function loadConverters() {
@@ -348,6 +349,9 @@ const typeLiteralConverter = {
         for (const signature of type.getCallSignatures()) {
             (0, signature_1.createSignature)(rc, models_1.ReflectionKind.CallSignature, signature);
         }
+        for (const signature of type.getConstructSignatures()) {
+            (0, signature_1.createSignature)(rc, models_1.ReflectionKind.ConstructorSignature, signature);
+        }
         (0, index_signature_1.convertIndexSignature)(rc, symbol);
         return new models_1.ReflectionType(reflection);
     },
@@ -364,6 +368,9 @@ const typeLiteralConverter = {
         for (const signature of type.getCallSignatures()) {
             (0, signature_1.createSignature)(context.withScope(reflection), models_1.ReflectionKind.CallSignature, signature);
         }
+        for (const signature of type.getConstructSignatures()) {
+            (0, signature_1.createSignature)(context.withScope(reflection), models_1.ReflectionKind.ConstructorSignature, signature);
+        }
         (0, index_signature_1.convertIndexSignature)(context.withScope(reflection), type.symbol);
         return new models_1.ReflectionType(reflection);
     },
@@ -570,7 +577,7 @@ const typeOperatorConverter = {
         // readonly is only valid on array and tuple literal types.
         if (node.operator === ts.SyntaxKind.ReadonlyKeyword) {
             const resolved = resolveReference(type);
-            assert(isObjectType(resolved));
+            assert((0, nodes_1.isObjectType)(resolved));
             const args = context.checker
                 .getTypeArguments(type)
                 .map((type) => convertType(context, type));
@@ -639,11 +646,8 @@ function requestBugReport(context, nodeOrType) {
         return new models_1.UnknownType(typeString);
     }
 }
-function isObjectType(type) {
-    return typeof type.objectFlags === "number";
-}
 function resolveReference(type) {
-    if (isObjectType(type) && type.objectFlags & ts.ObjectFlags.Reference) {
+    if ((0, nodes_1.isObjectType)(type) && type.objectFlags & ts.ObjectFlags.Reference) {
         return type.target;
     }
     return type;

package/dist/lib/converter/utils/nodes.d.ts

@@ -3,3 +3,4 @@ export declare function isNamedNode(node: ts.Node): node is ts.Node & {
     name: ts.Identifier | ts.PrivateIdentifier | ts.ComputedPropertyName;
 };
 export declare function getHeritageTypes(declarations: readonly (ts.ClassDeclaration | ts.InterfaceDeclaration)[], kind: ts.SyntaxKind.ImplementsKeyword | ts.SyntaxKind.ExtendsKeyword): ts.ExpressionWithTypeArguments[];
+export declare function isObjectType(type: ts.Type): type is ts.ObjectType;

package/dist/lib/converter/utils/nodes.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getHeritageTypes = exports.isNamedNode = void 0;
+exports.isObjectType = exports.getHeritageTypes = exports.isNamedNode = void 0;
 const ts = require("typescript");
 function isNamedNode(node) {
     const name = node.name;
@@ -22,3 +22,7 @@ function getHeritageTypes(declarations, kind) {
     });
 }
 exports.getHeritageTypes = getHeritageTypes;
+function isObjectType(type) {
+    return typeof type.objectFlags === "number";
+}
+exports.isObjectType = isObjectType;

package/dist/lib/models/reflections/declaration.d.ts

@@ -25,6 +25,13 @@ export interface DeclarationHierarchy {
      */
     isTarget?: boolean;
 }
+/**
+ * @internal
+ */
+export declare enum ConversionFlags {
+    None = 0,
+    VariableSource = 1
+}
 /**
  * A reflection that represents a single declaration emitted by the TypeScript compiler.
  *
@@ -118,6 +125,11 @@ export declare class DeclarationReflection extends ContainerReflection {
      * The version of the module when found.
      */
     version?: string;
+    /**
+     * Flags for information about a reflection which is needed solely during conversion.
+     * @internal
+     */
+    conversionFlags: ConversionFlags;
     hasGetterOrSetter(): boolean;
     getAllSignatures(): SignatureReflection[];
     /** @internal */

package/dist/lib/models/reflections/declaration.js

@@ -1,9 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DeclarationReflection = void 0;
+exports.DeclarationReflection = exports.ConversionFlags = void 0;
 const types_1 = require("../types");
 const abstract_1 = require("./abstract");
 const container_1 = require("./container");
+/**
+ * @internal
+ */
+var ConversionFlags;
+(function (ConversionFlags) {
+    ConversionFlags[ConversionFlags["None"] = 0] = "None";
+    ConversionFlags[ConversionFlags["VariableSource"] = 1] = "VariableSource";
+})(ConversionFlags = exports.ConversionFlags || (exports.ConversionFlags = {}));
 /**
  * A reflection that represents a single declaration emitted by the TypeScript compiler.
  *
@@ -11,6 +19,14 @@ const container_1 = require("./container");
  * kind of a reflection is stored in its ´kind´ member.
  */
 class DeclarationReflection extends container_1.ContainerReflection {
+    constructor() {
+        super(...arguments);
+        /**
+         * Flags for information about a reflection which is needed solely during conversion.
+         * @internal
+         */
+        this.conversionFlags = ConversionFlags.None;
+    }
     hasGetterOrSetter() {
         return !!this.getSignature || !!this.setSignature;
     }

package/dist/lib/models/reflections/index.d.ts

@@ -1,7 +1,7 @@
 export { Reflection, ReflectionFlag, ReflectionFlags, TraverseProperty, } from "./abstract";
 export type { TraverseCallback } from "./abstract";
 export { ContainerReflection } from "./container";
-export { DeclarationReflection } from "./declaration";
+export { DeclarationReflection, ConversionFlags } from "./declaration";
 export type { DeclarationHierarchy } from "./declaration";
 export { ReflectionKind } from "./kind";
 export { ParameterReflection } from "./parameter";

package/dist/lib/models/reflections/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.splitUnquotedString = exports.VarianceModifier = exports.TypeParameterReflection = exports.SignatureReflection = exports.ReferenceReflection = exports.ProjectReflection = exports.ParameterReflection = exports.ReflectionKind = exports.DeclarationReflection = exports.ContainerReflection = exports.TraverseProperty = exports.ReflectionFlags = exports.ReflectionFlag = exports.Reflection = void 0;
+exports.splitUnquotedString = exports.VarianceModifier = exports.TypeParameterReflection = exports.SignatureReflection = exports.ReferenceReflection = exports.ProjectReflection = exports.ParameterReflection = exports.ReflectionKind = exports.ConversionFlags = exports.DeclarationReflection = exports.ContainerReflection = exports.TraverseProperty = exports.ReflectionFlags = exports.ReflectionFlag = exports.Reflection = void 0;
 var abstract_1 = require("./abstract");
 Object.defineProperty(exports, "Reflection", { enumerable: true, get: function () { return abstract_1.Reflection; } });
 Object.defineProperty(exports, "ReflectionFlag", { enumerable: true, get: function () { return abstract_1.ReflectionFlag; } });
@@ -10,6 +10,7 @@ var container_1 = require("./container");
 Object.defineProperty(exports, "ContainerReflection", { enumerable: true, get: function () { return container_1.ContainerReflection; } });
 var declaration_1 = require("./declaration");
 Object.defineProperty(exports, "DeclarationReflection", { enumerable: true, get: function () { return declaration_1.DeclarationReflection; } });
+Object.defineProperty(exports, "ConversionFlags", { enumerable: true, get: function () { return declaration_1.ConversionFlags; } });
 var kind_1 = require("./kind");
 Object.defineProperty(exports, "ReflectionKind", { enumerable: true, get: function () { return kind_1.ReflectionKind; } });
 var parameter_1 = require("./parameter");

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

@@ -4,6 +4,7 @@ import { Reflection } from "./reflections/abstract";
 import type { DeclarationReflection } from "./reflections/declaration";
 import type { ProjectReflection } from "./reflections/project";
 import type { Serializer, JSONOutput } from "../serialization";
+import type { DeclarationReference } from "../converter/comments/declarationReference";
 /**
  * Base class of all type definitions.
  */
@@ -320,6 +321,10 @@ export declare class ReferenceType extends Type {
      * @internal
      */
     getSymbol(): ts.Symbol | undefined;
+    /**
+     * Convert this reference type to a declaration reference used for resolution of external types.
+     */
+    toDeclarationReference(): DeclarationReference;
     /**
      * 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.
@@ -330,10 +335,15 @@ export declare class ReferenceType extends Type {
      * Will only be set for `ReferenceType`s pointing to a symbol within `node_modules`.
      */
     package?: string;
+    /**
+     * 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?: string;
     private _target;
     private _project;
     private constructor();
-    static createResolvedReference(name: string, target: Reflection | number, project: ProjectReflection | null): ReferenceType;
+    static createResolvedReference(name: string, target: Reflection | number, project: ProjectReflection): ReferenceType;
     static createSymbolReference(symbol: ts.Symbol, context: Context, name?: string): ReferenceType;
     /** @internal this is used for type parameters, which don't actually point to something */
     static createBrokenReference(name: string, project: ProjectReflection): ReferenceType;

package/dist/lib/models/types.js

@@ -661,6 +661,20 @@ class ReferenceType extends Type {
         }
         return this._target;
     }
+    /**
+     * Convert this reference type to a declaration reference used for resolution of external types.
+     */
+    toDeclarationReference() {
+        return {
+            resolutionStart: "global",
+            moduleSource: this.package,
+            symbolReference: {
+                path: this.qualifiedName
+                    .split(".")
+                    .map((p) => ({ path: p, navigation: "." })),
+            },
+        };
+    }
     static createResolvedReference(name, target, project) {
         return new ReferenceType(name, target, project, name);
     }
@@ -709,6 +723,7 @@ class ReferenceType extends Type {
             id: this.reflection?.id,
             typeArguments: serializer.toObjectsOptional(this.typeArguments),
             name: this.name,
+            externalUrl: this.externalUrl,
         };
         if (this.package) {
             result.qualifiedName = this.qualifiedName;

package/dist/lib/output/renderer.d.ts

@@ -5,7 +5,6 @@ import { RendererComponent } from "./components";
 import { ChildableComponent } from "../utils/component";
 import { EventHooks } from "../utils";
 import type { Theme as ShikiTheme } from "shiki";
-import { ReferenceType } from "../models";
 import type { JsxElement } from "../utils/jsx.elements";
 import type { DefaultThemeRenderContext } from "./themes/default/DefaultThemeRenderContext";
 /**
@@ -80,7 +79,6 @@ export interface RendererHooks {
  */
 export declare class Renderer extends ChildableComponent<Application, RendererComponent> {
     private themes;
-    private unknownSymbolResolvers;
     /** @event */
     static readonly EVENT_BEGIN_PAGE = "beginPage";
     /** @event */
@@ -125,7 +123,7 @@ export declare class Renderer extends ChildableComponent<Application, RendererCo
      */
     defineTheme(name: string, theme: new (renderer: Renderer) => Theme): void;
     /**
-     * Adds a new resolver that the theme can used to try to figure out how to link to a symbol
+     * Adds a new resolver that the theme can use to try to figure out how to link to a symbol
      * declared by a third-party library which is not included in the documentation.
      * @param packageName the npm package name that this resolver can handle to limit which files it will be tried on.
      *   If the resolver will create links for Node builtin types, it should be set to `@types/node`.
@@ -133,15 +131,11 @@ export declare class Renderer extends ChildableComponent<Application, RendererCo
      * @param resolver a function that will be called to create links for a given symbol name in the registered path.
      *  If the provided name is not contained within the docs, should return `undefined`.
      * @since 0.22.0
+     * @deprecated
+     * Deprecated since v0.23.14, use {@link Converter.addUnknownSymbolResolver | Converter.addUnknownSymbolResolver} instead.
+     * This signature will be removed in 0.24 or possibly 0.25.
      */
     addUnknownSymbolResolver(packageName: string, resolver: (name: string) => string | undefined): void;
-    /**
-     * Marked as internal for now. Using this requires the internal `getSymbol()` method on ReferenceType.
-     * Someday that needs to be fixed so that this can be made public. ReferenceTypes really shouldn't store
-     * symbols so that we don't need to keep the program around forever.
-     * @internal
-     */
-    attemptExternalResolution(type: ReferenceType): string | undefined;
     /**
      * Render the given project reflection to the specified output directory.
      *

package/dist/lib/output/renderer.js

@@ -64,7 +64,6 @@ let Renderer = class Renderer extends component_1.ChildableComponent {
         this.themes = new Map([
             ["default", DefaultTheme_1.DefaultTheme],
         ]);
-        this.unknownSymbolResolvers = new Map();
         /**
          * Hooks which will be called when rendering pages.
          * Note:
@@ -89,7 +88,7 @@ let Renderer = class Renderer extends component_1.ChildableComponent {
         this.themes.set(name, theme);
     }
     /**
-     * Adds a new resolver that the theme can used to try to figure out how to link to a symbol
+     * Adds a new resolver that the theme can use to try to figure out how to link to a symbol
      * declared by a third-party library which is not included in the documentation.
      * @param packageName the npm package name that this resolver can handle to limit which files it will be tried on.
      *   If the resolver will create links for Node builtin types, it should be set to `@types/node`.
@@ -97,32 +96,19 @@ let Renderer = class Renderer extends component_1.ChildableComponent {
      * @param resolver a function that will be called to create links for a given symbol name in the registered path.
      *  If the provided name is not contained within the docs, should return `undefined`.
      * @since 0.22.0
+     * @deprecated
+     * Deprecated since v0.23.14, use {@link Converter.addUnknownSymbolResolver | Converter.addUnknownSymbolResolver} instead.
+     * This signature will be removed in 0.24 or possibly 0.25.
      */
     addUnknownSymbolResolver(packageName, resolver) {
-        const existing = this.unknownSymbolResolvers.get(packageName);
-        if (existing) {
-            existing.push(resolver);
-        }
-        else {
-            this.unknownSymbolResolvers.set(packageName, [resolver]);
-        }
-    }
-    /**
-     * Marked as internal for now. Using this requires the internal `getSymbol()` method on ReferenceType.
-     * Someday that needs to be fixed so that this can be made public. ReferenceTypes really shouldn't store
-     * symbols so that we don't need to keep the program around forever.
-     * @internal
-     */
-    attemptExternalResolution(type) {
-        if (!type.qualifiedName || !type.package) {
-            return;
-        }
-        const resolvers = this.unknownSymbolResolvers.get(type.package);
-        for (const resolver of resolvers || []) {
-            const resolved = resolver(type.qualifiedName);
-            if (resolved)
-                return resolved;
-        }
+        this.owner.converter.addUnknownSymbolResolver((ref) => {
+            const path = ref.symbolReference?.path
+                ?.map((path) => path.path)
+                .join(".");
+            if (ref.moduleSource === packageName && path) {
+                return resolver(path);
+            }
+        });
     }
     /**
      * Render the given project reflection to the specified output directory.

package/dist/lib/output/themes/default/DefaultThemeRenderContext.d.ts

@@ -12,7 +12,12 @@ export declare class DefaultThemeRenderContext {
     relativeURL: (url: string | undefined) => string | undefined;
     urlTo: (reflection: Reflection) => string | undefined;
     markdown: (md: readonly CommentDisplayPart[] | NeverIfInternal<string | undefined>) => string;
-    attemptExternalResolution: (type: ReferenceType) => string | undefined;
+    /**
+     * Using this method will repeat work already done, instead of calling it, use `type.externalUrl`.
+     * @deprecated
+     * Will be removed in 0.24.
+     */
+    attemptExternalResolution: (type: NeverIfInternal<ReferenceType>) => string | undefined;
     reflectionTemplate: (props: import("../..").PageEvent<import("../../../models").ContainerReflection>) => import("../../../utils/jsx.elements").JsxElement;
     indexTemplate: (props: import("../..").PageEvent<import("../../../models").ProjectReflection>) => import("../../../utils/jsx.elements").JsxElement;
     defaultLayout: (props: import("../..").PageEvent<Reflection>) => import("../../../utils/jsx.elements").JsxElement;
@@ -21,7 +26,7 @@ export declare class DefaultThemeRenderContext {
     comment: (props: Reflection) => import("../../../utils/jsx.elements").JsxElement | undefined;
     footer: () => import("../../../utils/jsx.elements").JsxElement | undefined;
     header: (props: import("../..").PageEvent<Reflection>) => import("../../../utils/jsx.elements").JsxElement;
-    hierarchy: (props: import("../../../models").DeclarationHierarchy | undefined) => import("../../../utils/jsx.elements").JsxElement;
+    hierarchy: (props: import("../../../models").DeclarationHierarchy | undefined) => import("../../../utils/jsx.elements").JsxElement | undefined;
     index: (props: import("../../../models").ContainerReflection) => import("../../../utils/jsx.elements").JsxElement;
     member: (props: import("../../../models").DeclarationReflection) => import("../../../utils/jsx.elements").JsxElement;
     memberDeclaration: (props: import("../../../models").DeclarationReflection) => import("../../../utils/jsx.elements").JsxElement;

package/dist/lib/output/themes/default/DefaultThemeRenderContext.js

@@ -48,8 +48,13 @@ class DefaultThemeRenderContext {
             }
             return md ? this.theme.markedPlugin.parseMarkdown(md) : "";
         };
+        /**
+         * Using this method will repeat work already done, instead of calling it, use `type.externalUrl`.
+         * @deprecated
+         * Will be removed in 0.24.
+         */
         this.attemptExternalResolution = (type) => {
-            return this.theme.owner.attemptExternalResolution(type);
+            return type.externalUrl;
         };
         this.reflectionTemplate = bind(reflection_1.reflectionTemplate, this);
         this.indexTemplate = bind(templates_1.indexTemplate, this);

package/dist/lib/output/themes/default/partials/hierarchy.d.ts

@@ -1,4 +1,4 @@
 import type { DefaultThemeRenderContext } from "../DefaultThemeRenderContext";
 import { JSX } from "../../../../utils";
 import type { DeclarationHierarchy } from "../../../../models";
-export declare const hierarchy: (context: DefaultThemeRenderContext, props: DeclarationHierarchy | undefined) => JSX.Element;
+export declare function hierarchy(context: DefaultThemeRenderContext, props: DeclarationHierarchy | undefined): JSX.Element | undefined;

package/dist/lib/output/themes/default/partials/hierarchy.js

@@ -2,9 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.hierarchy = void 0;
 const utils_1 = require("../../../../utils");
-const hierarchy = (context, props) => (utils_1.JSX.createElement(utils_1.JSX.Fragment, null, !!props && (utils_1.JSX.createElement("section", { class: "tsd-panel tsd-hierarchy" },
-    utils_1.JSX.createElement("h4", null, "Hierarchy"),
-    utils_1.JSX.createElement("ul", { class: "tsd-hierarchy" }, props.types.map((item, i, l) => (utils_1.JSX.createElement("li", null,
-        props.isTarget ? utils_1.JSX.createElement("span", { class: "target" }, item.toString()) : context.type(item),
-        i === l.length - 1 && !!props.next && context.hierarchy(props.next)))))))));
+function hierarchy(context, props) {
+    if (!props)
+        return;
+    return (utils_1.JSX.createElement("section", { class: "tsd-panel tsd-hierarchy" },
+        utils_1.JSX.createElement("h4", null, "Hierarchy"),
+        hierarchyList(context, props)));
+}
 exports.hierarchy = hierarchy;
+function hierarchyList(context, props) {
+    return (utils_1.JSX.createElement("ul", { class: "tsd-hierarchy" }, props.types.map((item, i, l) => (utils_1.JSX.createElement("li", null,
+        props.isTarget ? utils_1.JSX.createElement("span", { class: "target" }, item.toString()) : context.type(item),
+        i === l.length - 1 && !!props.next && hierarchyList(context, props.next))))));
+}

package/dist/lib/output/themes/default/partials/member.declaration.js

@@ -19,9 +19,7 @@ const memberDeclaration = (context, props) => (utils_1.JSX.createElement(utils_1
                 " = ",
                 props.defaultValue)))),
     context.comment(props),
-    (0, lib_1.hasTypeParameters)(props) && (utils_1.JSX.createElement(utils_1.JSX.Fragment, null,
-        utils_1.JSX.createElement("h4", { class: "tsd-type-parameters-title" }, "Type Parameters"),
-        context.typeParameters(props.typeParameters))),
+    (0, lib_1.hasTypeParameters)(props) && context.typeParameters(props.typeParameters),
     props.type instanceof models_1.ReflectionType && (utils_1.JSX.createElement("div", { class: "tsd-type-declaration" },
         utils_1.JSX.createElement("h4", null, "Type declaration"),
         context.parameter(props.type.declaration))),

package/dist/lib/output/themes/default/partials/member.signature.body.js

@@ -7,9 +7,7 @@ const lib_1 = require("../../lib");
 const memberSignatureBody = (context, props, { hideSources = false } = {}) => (utils_1.JSX.createElement(utils_1.JSX.Fragment, null,
     (0, lib_1.renderFlags)(props.flags, props.comment),
     context.comment(props),
-    (0, lib_1.hasTypeParameters)(props) && (utils_1.JSX.createElement("div", { class: "tsd-type-parameters" },
-        utils_1.JSX.createElement("h4", { class: "tsd-type-parameters-title" }, "Type Parameters"),
-        context.typeParameters(props.typeParameters))),
+    (0, lib_1.hasTypeParameters)(props) && context.typeParameters(props.typeParameters),
     props.parameters && props.parameters.length > 0 && (utils_1.JSX.createElement("div", { class: "tsd-parameters" },
         utils_1.JSX.createElement("h4", { class: "tsd-parameters-title" }, "Parameters"),
         utils_1.JSX.createElement("ul", { class: "tsd-parameter-list" }, props.parameters.map((item) => (utils_1.JSX.createElement("li", null,

package/dist/lib/output/themes/default/partials/type.js

@@ -175,14 +175,11 @@ const typeRenderers = {
                 name = renderUniquePath(context, reflection);
             }
         }
+        else if (type.externalUrl) {
+            name = (utils_1.JSX.createElement("a", { href: type.externalUrl, class: "tsd-signature-type external", target: "_blank" }, type.name));
+        }
         else {
-            const externalUrl = context.attemptExternalResolution(type);
-            if (externalUrl) {
-                name = (utils_1.JSX.createElement("a", { href: externalUrl, class: "tsd-signature-type external", target: "_blank" }, type.name));
-            }
-            else {
-                name = utils_1.JSX.createElement("span", { class: "tsd-signature-type" }, type.name);
-            }
+            name = utils_1.JSX.createElement("span", { class: "tsd-signature-type" }, type.name);
         }
         if (type.typeArguments?.length) {
             return (utils_1.JSX.createElement(utils_1.JSX.Fragment, null,

package/dist/lib/serialization/schema.d.ts

@@ -119,7 +119,7 @@ export interface PredicateType extends Type, S<M.PredicateType, "type" | "name"
 }
 export interface QueryType extends Type, S<M.QueryType, "type" | "queryType"> {
 }
-export interface ReferenceType extends Type, S<M.ReferenceType, "type" | "name" | "typeArguments" | "package"> {
+export interface ReferenceType extends Type, S<M.ReferenceType, "type" | "name" | "typeArguments" | "package" | "externalUrl"> {
     id?: number;
     qualifiedName?: string;
 }

package/dist/lib/utils/fs.js

@@ -149,10 +149,7 @@ function glob(pattern, root, options) {
             }
             if (child.isDirectory() && child.name !== "node_modules") {
                 const childPath = dir.concat(child.name);
-                if (mini.set.some((row) => mini.matchOne(childPath, 
-                // @ts-expect-error https://github.com/DefinitelyTyped/DefinitelyTyped/pull/62049
-                row, 
-                /* partial */ true))) {
+                if (mini.set.some((row) => mini.matchOne(childPath, row, /* partial */ true))) {
                     dirs.push(childPath);
                 }
             }

package/dist/lib/utils/options/declaration.d.ts

@@ -55,6 +55,7 @@ export interface TypeDocOptionMap {
     excludeInternal: boolean;
     excludePrivate: boolean;
     excludeProtected: boolean;
+    externalSymbolLinkMappings: ManuallyValidatedOption<Record<string, Record<string, string>>>;
     media: string;
     includes: string;
     out: string;
@@ -126,7 +127,7 @@ export declare type ValidationOptions = {
      */
     notExported: boolean;
     /**
-     * If set, TypeDoc will produce warnings about \{&amp;link\} tags which will produce broken links.
+     * If set, TypeDoc will produce warnings about \{\@link\} tags which will produce broken links.
      */
     invalidLink: boolean;
     /**

package/dist/lib/utils/options/sources/typedoc.js

@@ -89,6 +89,28 @@ function addTypeDocOptions(options) {
         help: "Ignore protected variables and methods.",
         type: declaration_1.ParameterType.Boolean,
     });
+    options.addDeclaration({
+        name: "externalSymbolLinkMappings",
+        help: "Define custom links for symbols not included in the documentation.",
+        type: declaration_1.ParameterType.Mixed,
+        defaultValue: {},
+        validate(value) {
+            const error = "externalSymbolLinkMappings must be a Record<package name, Record<symbol name, link>>";
+            if (!Validation.validate({}, value)) {
+                throw new Error(error);
+            }
+            for (const mappings of Object.values(value)) {
+                if (!Validation.validate({}, mappings)) {
+                    throw new Error(error);
+                }
+                for (const link of Object.values(mappings)) {
+                    if (typeof link !== "string") {
+                        throw new Error(error);
+                    }
+                }
+            }
+        },
+    });
     options.addDeclaration({
         name: "media",
         help: "Specify the location with media files that should be copied to the output directory.",

package/dist/lib/utils/reflections.d.ts

@@ -0,0 +1,5 @@
+import { ProjectReflection, ReferenceType, Reflection } from "../models";
+export declare function discoverAllReferenceTypes(project: ProjectReflection, forExportValidation: boolean): {
+    type: ReferenceType;
+    owner: Reflection;
+}[];

package/dist/lib/utils/reflections.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.discoverAllReferenceTypes = void 0;
+const models_1 = require("../models");
+function discoverAllReferenceTypes(project, forExportValidation) {
+    let current = project;
+    const queue = [];
+    const result = [];
+    const visitor = (0, models_1.makeRecursiveVisitor)({
+        reference(type) {
+            result.push({ type, owner: current });
+        },
+        reflection(type) {
+            queue.push(type.declaration);
+        },
+    });
+    const add = (item) => {
+        if (!item)
+            return;
+        if (item instanceof models_1.Reflection) {
+            queue.push(item);
+        }
+        else {
+            queue.push(...item);
+        }
+    };
+    do {
+        if (current instanceof models_1.ContainerReflection) {
+            add(current.children);
+        }
+        if (current instanceof models_1.DeclarationReflection) {
+            current.type?.visit(visitor);
+            add(current.typeParameters);
+            add(current.signatures);
+            add(current.indexSignature);
+            add(current.getSignature);
+            add(current.setSignature);
+            current.overwrites?.visit(visitor);
+            current.implementedTypes?.forEach((type) => type.visit(visitor));
+            if (!forExportValidation) {
+                current.inheritedFrom?.visit(visitor);
+                current.implementationOf?.visit(visitor);
+                current.extendedTypes?.forEach((t) => t.visit(visitor));
+                current.extendedBy?.forEach((t) => t.visit(visitor));
+                current.implementedBy?.forEach((t) => t.visit(visitor));
+            }
+        }
+        if (current instanceof models_1.SignatureReflection) {
+            add(current.parameters);
+            add(current.typeParameters);
+            current.type?.visit(visitor);
+            current.overwrites?.visit(visitor);
+            if (!forExportValidation) {
+                current.inheritedFrom?.visit(visitor);
+                current.implementationOf?.visit(visitor);
+            }
+        }
+        if (current instanceof models_1.ParameterReflection) {
+            current.type?.visit(visitor);
+        }
+        if (current instanceof models_1.TypeParameterReflection) {
+            current.type?.visit(visitor);
+            current.default?.visit(visitor);
+        }
+    } while ((current = queue.shift()));
+    return result;
+}
+exports.discoverAllReferenceTypes = discoverAllReferenceTypes;

package/dist/lib/validation/exports.d.ts

@@ -1,3 +1,3 @@
-import { ProjectReflection } from "../models";
+import type { ProjectReflection } from "../models";
 import type { Logger } from "../utils";
 export declare function validateExports(project: ProjectReflection, logger: Logger, intentionallyNotExported: readonly string[]): void;

package/dist/lib/validation/exports.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateExports = void 0;
 const ts = require("typescript");
-const models_1 = require("../models");
+const reflections_1 = require("../utils/reflections");
 function makeIntentionallyExportedHelper(intentional, logger) {
     const used = new Set();
     const processed = intentional.map((v) => {
@@ -45,73 +45,21 @@ function makeIntentionallyExportedHelper(intentional, logger) {
     };
 }
 function validateExports(project, logger, intentionallyNotExported) {
-    let current = project;
-    const queue = [];
     const intentional = makeIntentionallyExportedHelper(intentionallyNotExported, logger);
     const warned = new Set();
-    const visitor = (0, models_1.makeRecursiveVisitor)({
-        reference(type) {
-            // If we don't have a symbol, then this was an intentionally broken reference.
-            const symbol = type.getSymbol();
-            if (!type.reflection && symbol) {
-                if ((symbol.flags & ts.SymbolFlags.TypeParameter) === 0 &&
-                    !intentional.has(symbol, type.qualifiedName) &&
-                    !warned.has(symbol)) {
-                    warned.add(symbol);
-                    const decl = symbol.declarations[0];
-                    logger.warn(`${type.qualifiedName} is referenced by ${current.getFullName()} but not included in the documentation.`, decl);
-                }
+    for (const { type, owner } of (0, reflections_1.discoverAllReferenceTypes)(project, true)) {
+        // If we don't have a symbol, then this was an intentionally broken reference.
+        const symbol = type.getSymbol();
+        if (!type.reflection && !type.externalUrl && symbol) {
+            if ((symbol.flags & ts.SymbolFlags.TypeParameter) === 0 &&
+                !intentional.has(symbol, type.qualifiedName) &&
+                !warned.has(symbol)) {
+                warned.add(symbol);
+                const decl = symbol.declarations[0];
+                logger.warn(`${type.qualifiedName} is referenced by ${owner.getFullName()} but not included in the documentation.`, decl);
             }
-        },
-        reflection(type) {
-            queue.push(type.declaration);
-        },
-    });
-    const add = (item) => {
-        if (!item)
-            return;
-        if (item instanceof models_1.Reflection) {
-            queue.push(item);
-        }
-        else {
-            queue.push(...item);
-        }
-    };
-    do {
-        if (current instanceof models_1.ContainerReflection) {
-            add(current.children);
-        }
-        if (current instanceof models_1.DeclarationReflection) {
-            current.type?.visit(visitor);
-            add(current.typeParameters);
-            add(current.signatures);
-            add(current.indexSignature);
-            add(current.getSignature);
-            add(current.setSignature);
-            current.overwrites?.visit(visitor);
-            // Do not check inheritedFrom, it doesn't always make sense to export a base type.
-            // Do not validate implementationOf will always be defined or intentionally broken.
-            // Do not check extendedTypes, it doesn't always make sense to export a base type.
-            // Do not validate extendedBy, guaranteed to all be in the documentation.
-            current.implementedTypes?.forEach((type) => type.visit(visitor));
-            // Do not validate implementedBy, guaranteed to all be in the documentation.
-        }
-        if (current instanceof models_1.SignatureReflection) {
-            add(current.parameters);
-            add(current.typeParameters);
-            current.type?.visit(visitor);
-            current.overwrites?.visit(visitor);
-            // Do not check inheritedFrom, it doesn't always make sense to export a base type.
-            // Do not validate implementationOf will always be defined or intentionally broken.
         }
-        if (current instanceof models_1.ParameterReflection) {
-            current.type?.visit(visitor);
-        }
-        if (current instanceof models_1.TypeParameterReflection) {
-            current.type?.visit(visitor);
-            current.default?.visit(visitor);
-        }
-    } while ((current = queue.shift()));
+    }
     const unusedIntentional = intentional.getUnused();
     if (unusedIntentional.length) {
         logger.warn("The following symbols were marked as intentionally not exported, but were either not referenced in the documentation, or were exported:\n\t" +

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "typedoc",
   "description": "Create api documentation for TypeScript projects.",
-  "version": "0.23.13",
+  "version": "0.23.15",
   "homepage": "https://typedoc.org",
   "main": "./dist/index.js",
   "exports": {
@@ -35,7 +35,7 @@
   "devDependencies": {
     "@types/lunr": "^2.3.4",
     "@types/marked": "^4.0.6",
-    "@types/minimatch": "5.1.1",
+    "@types/minimatch": "5.1.2",
     "@types/mocha": "^9.1.1",
     "@types/node": "14",
     "@typescript-eslint/eslint-plugin": "^5.36.1",

package/static/style.css

@@ -1109,7 +1109,6 @@ ul.tsd-type-parameter-list h5 {
     background: var(--color-background-secondary);
     border-bottom: 1px var(--color-accent) solid;
     transition: transform 0.3s ease-in-out;
-    margin: 0 auto;
 }
 .tsd-page-toolbar a {
     color: var(--color-text);
@@ -1125,6 +1124,7 @@ ul.tsd-type-parameter-list h5 {
     display: flex;
     justify-content: space-between;
     height: 2.5rem;
+    margin: 0 auto;
 }
 .tsd-page-toolbar .table-cell {
     position: relative;