typedoc 0.23.26 → 0.24.0-beta.1

package/dist/lib/serialization/deserializer.js

@@ -0,0 +1,212 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Deserializer = void 0;
+const assert_1 = require("assert");
+const index_1 = require("../models/index");
+const array_1 = require("../utils/array");
+class Deserializer {
+    constructor(app) {
+        this.app = app;
+        this.deferred = [];
+        this.deserializers = [];
+        this.activeReflection = [];
+        this.reflectionBuilders = {
+            declaration(parent, obj) {
+                return new index_1.DeclarationReflection(obj.name, obj.kind, parent);
+            },
+            param(parent, obj) {
+                return new index_1.ParameterReflection(obj.name, obj.kind, parent);
+            },
+            project() {
+                throw new Error("Not supported, use Deserializer.reviveProject(s) instead.");
+            },
+            reference(parent, obj) {
+                // Ugly, but we don't have a reference yet!
+                return new index_1.ReferenceReflection(obj.name, 
+                /* target */ parent, parent);
+            },
+            signature(parent, obj) {
+                return new index_1.SignatureReflection(obj.name, obj.kind, parent);
+            },
+            typeParam(parent, obj) {
+                return new index_1.TypeParameterReflection(obj.name, parent, void 0);
+            },
+        };
+        this.typeBuilders = {
+            array(obj, de) {
+                return new index_1.ArrayType(de.reviveType(obj.elementType));
+            },
+            conditional(obj, de) {
+                return new index_1.ConditionalType(de.reviveType(obj.checkType), de.reviveType(obj.extendsType), de.reviveType(obj.trueType), de.reviveType(obj.falseType));
+            },
+            indexedAccess(obj, de) {
+                return new index_1.IndexedAccessType(de.reviveType(obj.objectType), de.reviveType(obj.indexType));
+            },
+            inferred(obj, de) {
+                return new index_1.InferredType(obj.name, de.reviveType(obj.constraint));
+            },
+            intersection(obj, de) {
+                return new index_1.IntersectionType(obj.types.map((t) => de.reviveType(t)));
+            },
+            intrinsic(obj) {
+                return new index_1.IntrinsicType(obj.name);
+            },
+            literal(obj) {
+                if (obj.value && typeof obj.value === "object") {
+                    return new index_1.LiteralType(BigInt(`${obj.value.negative ? "-" : ""}${obj.value.value}`));
+                }
+                return new index_1.LiteralType(obj.value);
+            },
+            mapped(obj, de) {
+                return new index_1.MappedType(obj.parameter, de.reviveType(obj.parameterType), de.reviveType(obj.templateType), obj.readonlyModifier, obj.optionalModifier, de.reviveType(obj.nameType));
+            },
+            optional(obj, de) {
+                return new index_1.OptionalType(de.reviveType(obj.elementType));
+            },
+            predicate(obj, de) {
+                return new index_1.PredicateType(obj.name, obj.asserts, de.reviveType(obj.targetType));
+            },
+            query(obj, de) {
+                return new index_1.QueryType(de.reviveType(obj.queryType));
+            },
+            reference(obj) {
+                // Correct reference will be restored in fromObject
+                return index_1.ReferenceType.createResolvedReference(obj.name, -2, null);
+            },
+            reflection(obj, de) {
+                return new index_1.ReflectionType(de.revive(obj.declaration, (o) => de.constructReflection(o)));
+            },
+            rest(obj, de) {
+                return new index_1.RestType(de.reviveType(obj.elementType));
+            },
+            templateLiteral(obj, de) {
+                return new index_1.TemplateLiteralType(obj.head, obj.tail.map(([t, s]) => [de.reviveType(t), s]));
+            },
+            tuple(obj, de) {
+                return new index_1.TupleType(obj.elements?.map((t) => de.reviveType(t)) || []);
+            },
+            namedTupleMember(obj, de) {
+                return new index_1.NamedTupleMember(obj.name, obj.isOptional, de.reviveType(obj.element));
+            },
+            typeOperator(obj, de) {
+                return new index_1.TypeOperatorType(de.reviveType(obj.target), obj.operator);
+            },
+            union(obj, de) {
+                return new index_1.UnionType(obj.types.map((t) => de.reviveType(t)));
+            },
+            unknown(obj) {
+                return new index_1.UnknownType(obj.name);
+            },
+        };
+        this.oldIdToNewId = {};
+    }
+    get logger() {
+        return this.app.logger;
+    }
+    addDeserializer(de) {
+        (0, array_1.insertPrioritySorted)(this.deserializers, de);
+    }
+    /**
+     * Revive a single project into the structure it was originally created with.
+     * This is generally not appropriate for merging multiple projects since projects may
+     * contain reflections in their root, not inside a module.
+     */
+    reviveProject(projectObj, name) {
+        (0, assert_1.ok)(this.deferred.length === 0, "Deserializer.defer was called when not deserializing");
+        const project = new index_1.ProjectReflection(name || projectObj.name);
+        project.registerReflection(project);
+        this.project = project;
+        this.oldIdToNewId = { [projectObj.id]: project.id };
+        this.fromObject(project, projectObj);
+        const deferred = this.deferred;
+        this.deferred = [];
+        for (const def of deferred) {
+            def(project);
+        }
+        (0, assert_1.ok)(this.deferred.length === 0, "Work may not be double deferred when deserializing.");
+        (0, assert_1.ok)(this.activeReflection.length === 0, "Imbalanced reflection deserialization");
+        this.project = undefined;
+        this.oldIdToNewId = {};
+        return project;
+    }
+    reviveProjects(name, projects) {
+        if (projects.length === 1) {
+            return this.reviveProject(projects[0], name);
+        }
+        const project = new index_1.ProjectReflection(name);
+        project.children = [];
+        this.project = project;
+        for (const proj of projects) {
+            (0, assert_1.ok)(this.deferred.length === 0, "Deserializer.defer was called when not deserializing");
+            const projModule = new index_1.DeclarationReflection(proj.name, index_1.ReflectionKind.Module, project);
+            project.registerReflection(projModule);
+            project.children.push(projModule);
+            this.oldIdToNewId = { [proj.id]: projModule.id };
+            this.fromObject(projModule, proj);
+            const deferred = this.deferred;
+            this.deferred = [];
+            for (const def of deferred) {
+                def(project);
+            }
+            (0, assert_1.ok)(this.deferred.length === 0, "Work may not be double deferred when deserializing.");
+            (0, assert_1.ok)(this.activeReflection.length === 0, "Imbalanced reflection deserialization");
+        }
+        this.oldIdToNewId = {};
+        this.project = undefined;
+        return project;
+    }
+    revive(source, creator) {
+        if (source) {
+            const revived = creator(source);
+            this.fromObject(revived, source);
+            return revived;
+        }
+    }
+    reviveMany(sourceArray, creator) {
+        if (sourceArray) {
+            return sourceArray.map((item) => {
+                const revived = creator(item);
+                this.fromObject(revived, item);
+                return revived;
+            });
+        }
+    }
+    reviveType(obj) {
+        return this.revive(obj, (o) => this.constructType(o));
+    }
+    constructReflection(obj) {
+        (0, assert_1.ok)(this.activeReflection.length > 0);
+        const result = this.reflectionBuilders[obj.variant](this.activeReflection[this.activeReflection.length - 1], obj);
+        this.oldIdToNewId[obj.id] = result.id;
+        this.project.registerReflection(result);
+        return result;
+    }
+    constructType(obj) {
+        const result = this.typeBuilders[obj.type](obj, this);
+        return result;
+    }
+    fromObject(receiver, obj) {
+        if (receiver instanceof index_1.Reflection) {
+            this.activeReflection.push(receiver);
+        }
+        receiver.fromObject(this, obj);
+        for (const de of this.deserializers) {
+            if (de.supports(receiver, obj)) {
+                de.fromObject(receiver, obj);
+            }
+        }
+        if (receiver instanceof index_1.Reflection) {
+            this.activeReflection.pop();
+        }
+    }
+    /**
+     * Defers work until the initial pass of serialization has been completed.
+     * This can be used to set up references which cannot be immediately restored.
+     *
+     * May only be called when deserializing.
+     */
+    defer(cb) {
+        this.deferred.push(cb);
+    }
+}
+exports.Deserializer = Deserializer;

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

@@ -1,13 +1,6 @@
 import { Event } from "../utils/events";
 import type { ProjectReflection } from "../models";
 import type { ProjectReflection as JSONProjectReflection } from "./schema";
-/**
- * Optional data associated with the {@link SerializeEvent}.
- */
-export interface SerializeEventData {
-    outputDirectory?: string;
-    outputFile?: string;
-}
 /**
  * An event emitted by the {@link Serializer} class at the very beginning and
  * ending of the a project serialization process.
@@ -20,14 +13,6 @@ export declare class SerializeEvent extends Event {
      * The project the renderer is currently processing.
      */
     readonly project: ProjectReflection;
-    /**
-     * The path of the directory the serialized JSON should be written to.
-     */
-    outputDirectory?: string;
-    /**
-     * The name of the main JSON file (base + ext)
-     */
-    outputFile?: string;
     output: JSONProjectReflection | undefined;
     constructor(name: string, project: ProjectReflection, output?: JSONProjectReflection);
 }

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

@@ -1,6 +1,5 @@
 export type { SerializerComponent } from "./components";
+export { Deserializer, type Deserializable, type DeserializerComponent, } from "./deserializer";
 export { SerializeEvent } from "./events";
-export type { SerializeEventData } from "./events";
+export * as JSONOutput from "./schema";
 export { Serializer } from "./serializer";
-export { JSONOutput };
-import * as JSONOutput from "./schema";

package/dist/lib/serialization/index.js

@@ -23,10 +23,11 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.JSONOutput = exports.Serializer = exports.SerializeEvent = void 0;
+exports.Serializer = exports.JSONOutput = exports.SerializeEvent = exports.Deserializer = void 0;
+var deserializer_1 = require("./deserializer");
+Object.defineProperty(exports, "Deserializer", { enumerable: true, get: function () { return deserializer_1.Deserializer; } });
 var events_1 = require("./events");
 Object.defineProperty(exports, "SerializeEvent", { enumerable: true, get: function () { return events_1.SerializeEvent; } });
+exports.JSONOutput = __importStar(require("./schema"));
 var serializer_1 = require("./serializer");
 Object.defineProperty(exports, "Serializer", { enumerable: true, get: function () { return serializer_1.Serializer; } });
-const JSONOutput = __importStar(require("./schema"));
-exports.JSONOutput = JSONOutput;

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

@@ -32,7 +32,7 @@ import type * as M from "../models";
  * Describes the mapping from Model types to the corresponding JSON output type.
  */
 export type ModelToObject<T> = T extends Array<infer U> ? _ModelToObject<U>[] : _ModelToObject<T>;
-type _ModelToObject<T> = T extends Primitive ? T : T extends M.ReflectionGroup ? ReflectionGroup : T extends M.ReflectionCategory ? ReflectionCategory : T extends M.SignatureReflection ? SignatureReflection : T extends M.ParameterReflection ? ParameterReflection : T extends M.DeclarationReflection ? DeclarationReflection : T extends M.TypeParameterReflection ? TypeParameterReflection : T extends M.ProjectReflection ? ProjectReflection : T extends M.ContainerReflection ? ContainerReflection : T extends M.ReferenceReflection ? ReferenceReflection : T extends M.Reflection ? Reflection : T extends M.SomeType ? TypeKindMap[T["type"]] : T extends M.Type ? SomeType : T extends M.Comment ? Comment : T extends M.CommentTag ? CommentTag : T extends M.CommentDisplayPart ? CommentDisplayPart : T extends M.SourceReference ? SourceReference : never;
+type _ModelToObject<T> = T extends Primitive ? T : Required<T> extends Required<M.ReflectionGroup> ? ReflectionGroup : Required<T> extends Required<M.ReflectionCategory> ? ReflectionCategory : T extends M.SignatureReflection ? SignatureReflection : T extends M.ParameterReflection ? ParameterReflection : T extends M.DeclarationReflection ? DeclarationReflection : T extends M.TypeParameterReflection ? TypeParameterReflection : T extends M.ProjectReflection ? ProjectReflection : T extends M.ContainerReflection ? ContainerReflection : T extends M.ReferenceReflection ? ReferenceReflection : T extends M.Reflection ? Reflection : T extends M.SomeType ? TypeKindMap[T["type"]] : T extends M.Type ? SomeType : T extends M.Comment ? Comment : T extends M.CommentTag ? CommentTag : T extends M.CommentDisplayPart ? CommentDisplayPart : T extends M.SourceReference ? SourceReference : never;
 type Primitive = string | number | undefined | null | boolean;
 type ToSerialized<T> = T extends Primitive ? T : T extends bigint ? {
     value: string;
@@ -47,35 +47,42 @@ type ToSerialized<T> = T extends Primitive ? T : T extends bigint ? {
 type S<T, K extends keyof T> = {
     -readonly [K2 in K]: ToSerialized<T[K2]>;
 };
+export interface ReflectionSymbolId {
+    sourceFileName: string;
+    qualifiedName: string;
+}
 export interface ReflectionGroup extends S<M.ReflectionGroup, "title" | "categories"> {
     children?: M.ReflectionGroup["children"][number]["id"][];
 }
 export interface ReflectionCategory extends S<M.ReflectionCategory, "title"> {
     children?: M.ReflectionCategory["children"][number]["id"][];
 }
-export interface ReferenceReflection extends DeclarationReflection, S<M.ReferenceReflection, never> {
+export type SomeReflection = {
+    [K in keyof M.ReflectionVariant]: ModelToObject<M.ReflectionVariant[K]>;
+}[keyof M.ReflectionVariant];
+export interface ReferenceReflection extends Omit<DeclarationReflection, "variant">, S<M.ReferenceReflection, "variant"> {
     /**
      * -1 if the reference refers to a symbol that does not exist in the documentation.
      * Otherwise, the reflection ID.
      */
     target: number;
 }
-export interface SignatureReflection extends Reflection, S<M.SignatureReflection, "parameters" | "type" | "overwrites" | "inheritedFrom" | "implementationOf"> {
+export interface SignatureReflection extends Omit<Reflection, "variant">, S<M.SignatureReflection, "variant" | "sources" | "parameters" | "type" | "overwrites" | "inheritedFrom" | "implementationOf"> {
     typeParameter?: ModelToObject<M.SignatureReflection["typeParameters"]>;
 }
-export interface ParameterReflection extends Reflection, S<M.ParameterReflection, "type" | "defaultValue"> {
+export interface ParameterReflection extends Omit<Reflection, "variant">, S<M.ParameterReflection, "variant" | "type" | "defaultValue"> {
+    variant: "param";
 }
-export interface DeclarationReflection extends ContainerReflection, S<M.DeclarationReflection, "type" | "signatures" | "indexSignature" | "defaultValue" | "overwrites" | "inheritedFrom" | "implementationOf" | "extendedTypes" | "extendedBy" | "implementedTypes" | "implementedBy" | "getSignature" | "setSignature" | "typeParameters"> {
+export interface DeclarationReflection extends Omit<ContainerReflection, "variant">, S<M.DeclarationReflection, "variant" | "packageVersion" | "sources" | "relevanceBoost" | "type" | "signatures" | "indexSignature" | "defaultValue" | "overwrites" | "inheritedFrom" | "implementationOf" | "extendedTypes" | "extendedBy" | "implementedTypes" | "implementedBy" | "getSignature" | "setSignature" | "typeParameters"> {
 }
-export interface TypeParameterReflection extends Reflection, S<M.TypeParameterReflection, "type" | "default" | "varianceModifier"> {
+export interface TypeParameterReflection extends Omit<Reflection, "variant">, S<M.TypeParameterReflection, "variant" | "type" | "default" | "varianceModifier"> {
 }
-export interface ProjectReflection extends ContainerReflection {
+export interface ProjectReflection extends Omit<ContainerReflection, "variant">, S<M.ProjectReflection, "variant" | "packageName" | "packageVersion" | "readme"> {
+    symbolIdMap: Record<number, ReflectionSymbolId>;
 }
-export interface ContainerReflection extends Reflection, S<M.ContainerReflection, "children" | "groups" | "categories" | "sources"> {
+export interface ContainerReflection extends Reflection, S<M.ContainerReflection, "children" | "groups" | "categories"> {
 }
-export interface Reflection extends S<M.Reflection, "id" | "name" | "kind" | "kindString" | "comment"> {
-    /** Will not be present if name === originalName */
-    originalName?: M.Reflection["originalName"];
+export interface Reflection extends S<M.Reflection, "id" | "variant" | "name" | "kind" | "comment"> {
     flags: ReflectionFlags;
 }
 export type SomeType = ModelToObject<M.SomeType>;
@@ -94,9 +101,9 @@ export type TypeKindMap = {
     reference: ReferenceType;
     reflection: ReflectionType;
     rest: RestType;
-    "template-literal": TemplateLiteralType;
+    templateLiteral: TemplateLiteralType;
     tuple: TupleType;
-    "named-tuple-member": NamedTupleMemberType;
+    namedTupleMember: NamedTupleMemberType;
     typeOperator: TypeOperatorType;
     union: UnionType;
     unknown: UnknownType;
@@ -120,11 +127,10 @@ 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" | "externalUrl"> {
-    id?: number;
+    target: number | ReflectionSymbolId;
     qualifiedName?: string;
 }
-export interface ReflectionType extends Type, S<M.ReflectionType, "type"> {
-    declaration?: ModelToObject<M.ReflectionType["declaration"]>;
+export interface ReflectionType extends Type, S<M.ReflectionType, "type" | "declaration"> {
 }
 export interface RestType extends Type, S<M.RestType, "type" | "elementType"> {
 }
@@ -153,7 +159,7 @@ type BoolKeys<T> = {
 }[keyof T];
 export interface ReflectionFlags extends Partial<S<M.ReflectionFlags, BoolKeys<M.ReflectionFlags>>> {
 }
-export interface Comment extends Partial<S<M.Comment, "blockTags">> {
+export interface Comment extends Partial<S<M.Comment, "blockTags" | "label">> {
     summary: CommentDisplayPart[];
     modifierTags?: string[];
 }

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

@@ -1,6 +1,5 @@
 import { EventDispatcher } from "../utils";
 import type { ProjectReflection } from "../models";
-import { SerializeEventData } from "./events";
 import type { ModelToObject } from "./schema";
 import type { SerializerComponent } from "./components";
 export declare class Serializer extends EventDispatcher {
@@ -15,6 +14,10 @@ export declare class Serializer extends EventDispatcher {
      */
     static EVENT_END: string;
     private serializers;
+    /**
+     * Only set after resolve.
+     */
+    projectRoot: string;
     addSerializer(serializer: SerializerComponent<any>): void;
     toObject<T extends {
         toObject(serializer: Serializer): ModelToObject<T>;
@@ -30,8 +33,5 @@ export declare class Serializer extends EventDispatcher {
      * @param value
      * @param eventData Partial information to set in the event
      */
-    projectToObject(value: ProjectReflection, eventData?: {
-        begin?: SerializeEventData;
-        end?: SerializeEventData;
-    }): ModelToObject<ProjectReflection>;
+    projectToObject(value: ProjectReflection, projectRoot: string): ModelToObject<ProjectReflection>;
 }

package/dist/lib/serialization/serializer.js

@@ -3,18 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Serializer = void 0;
 const utils_1 = require("../utils");
 const events_1 = require("./events");
+const array_1 = require("../utils/array");
 class Serializer extends utils_1.EventDispatcher {
     constructor() {
         super(...arguments);
         this.serializers = [];
     }
     addSerializer(serializer) {
-        if ("serializeGroup" in serializer) {
-            // Remove this check in 0.24
-            throw new Error("Support for `serializeGroup` was removed. Use supports instead.");
-        }
-        this.serializers.push(serializer);
-        this.serializers.sort((a, b) => b.priority - a.priority);
+        (0, array_1.insertPrioritySorted)(this.serializers, serializer);
     }
     toObject(value) {
         if (value === undefined) {
@@ -35,19 +31,12 @@ class Serializer extends utils_1.EventDispatcher {
      * @param value
      * @param eventData Partial information to set in the event
      */
-    projectToObject(value, eventData = {}) {
+    projectToObject(value, projectRoot) {
+        this.projectRoot = projectRoot;
         const eventBegin = new events_1.SerializeEvent(Serializer.EVENT_BEGIN, value);
-        if (eventData.begin) {
-            eventBegin.outputDirectory = eventData.begin.outputDirectory;
-            eventBegin.outputFile = eventData.begin.outputFile;
-        }
         this.trigger(eventBegin);
         const project = this.toObject(value);
         const eventEnd = new events_1.SerializeEvent(Serializer.EVENT_END, value, project);
-        if (eventData.end) {
-            eventBegin.outputDirectory = eventData.end.outputDirectory;
-            eventBegin.outputFile = eventData.end.outputFile;
-        }
         this.trigger(eventEnd);
         return project;
     }

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

@@ -3,7 +3,6 @@
  * the item will be inserted later will be placed earlier in the array.
  * @param arr modified by inserting item.
  * @param item
- * @deprecated this is confusing, it sorts with lower priority being placed earlier. Prefer insertOrderSorted, which is nearly the same.
  */
 export declare function insertPrioritySorted<T extends {
     priority: number;

package/dist/lib/utils/array.js

@@ -6,10 +6,9 @@ exports.filterMap = exports.zip = exports.partition = exports.unique = exports.r
  * the item will be inserted later will be placed earlier in the array.
  * @param arr modified by inserting item.
  * @param item
- * @deprecated this is confusing, it sorts with lower priority being placed earlier. Prefer insertOrderSorted, which is nearly the same.
  */
 function insertPrioritySorted(arr, item) {
-    const index = binaryFindPartition(arr, (v) => v.priority >= item.priority);
+    const index = binaryFindPartition(arr, (v) => v.priority <= item.priority);
     arr.splice(index === -1 ? arr.length : index, 0, item);
     return arr;
 }

package/dist/lib/utils/entry-point.d.ts

@@ -1,4 +1,4 @@
-import ts from "typescript";
+import * as ts from "typescript";
 import type { Logger } from "./loggers";
 import type { Options } from "./options";
 /**
@@ -7,7 +7,7 @@ import type { Options } from "./options";
  */
 export declare const EntryPointStrategy: {
     /**
-     * The default behavior in v0.22+, expects all provided entry points as being part of a single program.
+     * The default behavior in v0.22-v0.23, expects all provided entry points as being part of a single program.
      * Any directories included in the entry point list will result in `dir/index.([cm][tj]s|[tj]sx?)` being used.
      */
     readonly Resolve: "resolve";
@@ -17,12 +17,22 @@ export declare const EntryPointStrategy: {
      */
     readonly Expand: "expand";
     /**
+     * Run TypeDoc in each directory passed as an entry point, and save the json result to `.typedoc/<project>`
+     * Once all have been saved, use the merge option to produce final output.
+     */
+    readonly Packages: "packages";
+    /**
+     * Will be removed in 0.25, this was called packages mode in 0.24.
      * Alternative resolution mode useful for monorepos. With this mode, TypeDoc will look for a package.json
      * and tsconfig.json under each provided entry point. The `main` field of each package will be documented.
      */
-    readonly Packages: "packages";
+    readonly LegacyPackages: "legacy-packages";
+    /**
+     * Merges multiple previously generated output from TypeDoc's --json output together into a single project.
+     */
+    readonly Merge: "merge";
 };
-export type EntryPointStrategy = (typeof EntryPointStrategy)[keyof typeof EntryPointStrategy];
+export type EntryPointStrategy = typeof EntryPointStrategy[keyof typeof EntryPointStrategy];
 export interface DocumentationEntryPoint {
     displayName: string;
     readmeFile?: string;
@@ -32,4 +42,5 @@ export interface DocumentationEntryPoint {
 }
 export declare function getEntryPoints(logger: Logger, options: Options): DocumentationEntryPoint[] | undefined;
 export declare function getWatchEntryPoints(logger: Logger, options: Options, program: ts.Program): DocumentationEntryPoint[] | undefined;
+export declare function getPackageDirectories(logger: Logger, options: Options, packageGlobPaths: string[]): string[];
 export declare function getExpandedEntryPointsForPaths(logger: Logger, inputFiles: string[], options: Options, programs?: ts.Program[]): DocumentationEntryPoint[] | undefined;