typedoc 0.28.19 → 0.28.20

package/dist/serialization.js

@@ -0,0 +1,430 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/lib/serialization/deserializer.ts
+import {
+  ArrayType,
+  ConditionalType,
+  DeclarationReflection,
+  DocumentReflection,
+  IndexedAccessType,
+  InferredType,
+  IntersectionType,
+  IntrinsicType,
+  LiteralType,
+  MappedType,
+  NamedTupleMember,
+  OptionalType,
+  ParameterReflection,
+  PredicateType,
+  ProjectReflection,
+  QueryType,
+  ReferenceReflection,
+  ReferenceType,
+  Reflection,
+  ReflectionKind,
+  ReflectionType,
+  RestType,
+  SignatureReflection,
+  TemplateLiteralType,
+  TupleType,
+  TypeOperatorType,
+  TypeParameterReflection,
+  UnionType,
+  UnknownType
+} from "#models";
+import { assert, insertPrioritySorted } from "#utils";
+
+// src/lib/serialization/schema.ts
+var schema_exports = {};
+__export(schema_exports, {
+  SCHEMA_VERSION: () => SCHEMA_VERSION
+});
+var SCHEMA_VERSION = "2.0";
+
+// src/lib/serialization/deserializer.ts
+var supportedSchemaVersions = [SCHEMA_VERSION];
+var Deserializer = class {
+  constructor(logger) {
+    this.logger = logger;
+  }
+  logger;
+  deferred = [];
+  deserializers = [];
+  activeReflection = [];
+  reflectionBuilders = {
+    declaration(parent, obj) {
+      return new DeclarationReflection(obj.name, obj.kind, parent);
+    },
+    document(parent, obj) {
+      return new DocumentReflection(obj.name, parent, [], {});
+    },
+    param(parent, obj) {
+      return new ParameterReflection(obj.name, obj.kind, parent);
+    },
+    project() {
+      throw new Error(
+        "Not supported, use Deserializer.reviveProject(s) instead."
+      );
+    },
+    reference(parent, obj) {
+      return new ReferenceReflection(
+        obj.name,
+        /* target */
+        parent,
+        parent
+      );
+    },
+    signature(parent, obj) {
+      return new SignatureReflection(
+        obj.name,
+        obj.kind,
+        parent
+      );
+    },
+    typeParam(parent, obj) {
+      return new TypeParameterReflection(obj.name, parent, void 0);
+    }
+  };
+  typeBuilders = {
+    array(obj, de) {
+      return new ArrayType(de.reviveType(obj.elementType));
+    },
+    conditional(obj, de) {
+      return new ConditionalType(
+        de.reviveType(obj.checkType),
+        de.reviveType(obj.extendsType),
+        de.reviveType(obj.trueType),
+        de.reviveType(obj.falseType)
+      );
+    },
+    indexedAccess(obj, de) {
+      return new IndexedAccessType(
+        de.reviveType(obj.objectType),
+        de.reviveType(obj.indexType)
+      );
+    },
+    inferred(obj, de) {
+      return new InferredType(obj.name, de.reviveType(obj.constraint));
+    },
+    intersection(obj, de) {
+      return new IntersectionType(obj.types.map((t) => de.reviveType(t)));
+    },
+    intrinsic(obj) {
+      return new IntrinsicType(obj.name);
+    },
+    literal(obj) {
+      if (typeof obj.value === "object" && obj.value != null) {
+        return new LiteralType(
+          BigInt(
+            `${obj.value.negative ? "-" : ""}${obj.value.value}`
+          )
+        );
+      }
+      return new LiteralType(obj.value);
+    },
+    mapped(obj, de) {
+      return new MappedType(
+        obj.parameter,
+        de.reviveType(obj.parameterType),
+        de.reviveType(obj.templateType),
+        obj.readonlyModifier,
+        obj.optionalModifier,
+        de.reviveType(obj.nameType)
+      );
+    },
+    optional(obj, de) {
+      return new OptionalType(de.reviveType(obj.elementType));
+    },
+    predicate(obj, de) {
+      return new PredicateType(
+        obj.name,
+        obj.asserts,
+        de.reviveType(obj.targetType)
+      );
+    },
+    query(obj, de) {
+      return new QueryType(de.reviveType(obj.queryType));
+    },
+    reference(obj) {
+      return ReferenceType.createResolvedReference(obj.name, -2, null);
+    },
+    reflection(obj, de) {
+      return new ReflectionType(
+        de.revive(obj.declaration, (o) => de.constructReflection(o))
+      );
+    },
+    rest(obj, de) {
+      return new RestType(de.reviveType(obj.elementType));
+    },
+    templateLiteral(obj, de) {
+      return new TemplateLiteralType(
+        obj.head,
+        obj.tail.map(([t, s]) => [de.reviveType(t), s])
+      );
+    },
+    tuple(obj, de) {
+      return new TupleType(
+        obj.elements?.map((t) => de.reviveType(t)) || []
+      );
+    },
+    namedTupleMember(obj, de) {
+      return new NamedTupleMember(
+        obj.name,
+        obj.isOptional,
+        de.reviveType(obj.element)
+      );
+    },
+    typeOperator(obj, de) {
+      return new TypeOperatorType(
+        de.reviveType(obj.target),
+        obj.operator
+      );
+    },
+    union(obj, de) {
+      return new UnionType(obj.types.map((t) => de.reviveType(t)));
+    },
+    unknown(obj) {
+      return new UnknownType(obj.name);
+    }
+  };
+  /**
+   * Only set when deserializing.
+   */
+  projectRoot;
+  oldIdToNewId = {};
+  oldFileIdToNewFileId = {};
+  project;
+  addDeserializer(de) {
+    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(name, projectObj, options) {
+    assert(
+      this.deferred.length === 0,
+      "Deserializer.defer was called when not deserializing"
+    );
+    if (!supportedSchemaVersions.includes(projectObj.schemaVersion)) {
+      throw new Error(
+        `Attempted to deserialize version "${projectObj.schemaVersion}" JSON, which is not supported. Supported versions: ${supportedSchemaVersions.join(", ")}`
+      );
+    }
+    const project = new ProjectReflection(
+      name || projectObj.name,
+      options.registry
+    );
+    this.project = project;
+    this.projectRoot = options.projectRoot;
+    this.oldIdToNewId = { [projectObj.id]: project.id };
+    this.oldFileIdToNewFileId = {};
+    this.fromObject(project, projectObj);
+    const deferred = this.deferred;
+    this.deferred = [];
+    for (const def of deferred) {
+      def(project);
+    }
+    assert(
+      this.deferred.length === 0,
+      "Work may not be double deferred when deserializing."
+    );
+    assert(
+      this.activeReflection.length === 0,
+      "Imbalanced reflection deserialization"
+    );
+    this.project = void 0;
+    this.projectRoot = void 0;
+    this.oldIdToNewId = {};
+    this.oldFileIdToNewFileId = {};
+    return project;
+  }
+  reviveProjects(name, projects, options) {
+    if (projects.length === 1 && !options.alwaysCreateEntryPointModule) {
+      return this.reviveProject(name, projects[0], options);
+    }
+    const project = new ProjectReflection(name, options.registry);
+    this.project = project;
+    this.projectRoot = options.projectRoot;
+    for (const proj of projects) {
+      assert(
+        this.deferred.length === 0,
+        "Deserializer.defer was called when not deserializing"
+      );
+      if (!supportedSchemaVersions.includes(proj.schemaVersion)) {
+        throw new Error(
+          `Attempted to deserialize version "${proj.schemaVersion}" JSON, which is not supported. Supported versions: ${supportedSchemaVersions.join(", ")}`
+        );
+      }
+      const projModule = new DeclarationReflection(
+        proj.name,
+        ReflectionKind.Module,
+        project
+      );
+      project.registerReflection(projModule, void 0, void 0);
+      project.addChild(projModule);
+      this.oldIdToNewId = { [proj.id]: projModule.id };
+      this.oldFileIdToNewFileId = {};
+      this.fromObject(projModule, proj);
+      const deferred = this.deferred;
+      this.deferred = [];
+      for (const def of deferred) {
+        def(project);
+      }
+      assert(
+        this.deferred.length === 0,
+        "Work may not be double deferred when deserializing."
+      );
+      assert(
+        this.activeReflection.length === 0,
+        "Imbalanced reflection deserialization"
+      );
+    }
+    this.oldIdToNewId = {};
+    this.oldFileIdToNewFileId = {};
+    this.project = void 0;
+    this.projectRoot = void 0;
+    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) {
+    assert(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, void 0, void 0);
+    return result;
+  }
+  constructType(obj) {
+    const result = this.typeBuilders[obj.type](obj, this);
+    return result;
+  }
+  fromObject(receiver, obj) {
+    if (receiver instanceof 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 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);
+  }
+};
+
+// src/lib/serialization/events.ts
+var SerializeEvent = class {
+  /**
+   * The project the renderer is currently processing.
+   */
+  project;
+  output;
+  constructor(project, output) {
+    this.project = project;
+    this.output = output;
+  }
+};
+
+// src/lib/serialization/serializer.ts
+import { EventDispatcher, insertPrioritySorted as insertPrioritySorted2, removeIfPresent } from "#utils";
+var Serializer = class _Serializer extends EventDispatcher {
+  /**
+   * Triggered when the {@link Serializer} begins transforming a project.
+   * @event
+   */
+  static EVENT_BEGIN = "begin";
+  /**
+   * Triggered when the {@link Serializer} has finished transforming a project.
+   * @event
+   */
+  static EVENT_END = "end";
+  serializers = [];
+  /**
+   * Only set when serializing.
+   */
+  projectRoot;
+  /**
+   * Only set when serializing
+   */
+  project;
+  addSerializer(serializer) {
+    insertPrioritySorted2(this.serializers, serializer);
+  }
+  removeSerializer(serializer) {
+    removeIfPresent(this.serializers, serializer);
+  }
+  toObject(value) {
+    if (value === void 0) {
+      return void 0;
+    }
+    return this.serializers.filter((s) => s.supports(value)).reduce(
+      (val, s) => s.toObject(value, val, this),
+      value.toObject(this)
+    );
+  }
+  toObjectsOptional(value) {
+    if (!value || value.length === 0) {
+      return void 0;
+    }
+    return value.map((val) => this.toObject(val));
+  }
+  /**
+   * Same as toObject but emits {@link Serializer.EVENT_BEGIN} and {@link Serializer.EVENT_END} events.
+   * @param value
+   */
+  projectToObject(value, projectRoot) {
+    this.projectRoot = projectRoot;
+    this.project = value;
+    const eventBegin = new SerializeEvent(value);
+    this.trigger(_Serializer.EVENT_BEGIN, eventBegin);
+    const project = this.toObject(value);
+    const eventEnd = new SerializeEvent(value, project);
+    this.trigger(_Serializer.EVENT_END, eventEnd);
+    this.project = void 0;
+    this.projectRoot = void 0;
+    return project;
+  }
+};
+export {
+  Deserializer,
+  schema_exports as JSONOutput,
+  SerializeEvent,
+  Serializer
+};

package/dist/{lib → types}/application-events.d.ts

@@ -2,4 +2,6 @@ export declare const ApplicationEvents: {
     readonly BOOTSTRAP_END: "bootstrapEnd";
     readonly REVIVE: "reviveProject";
     readonly VALIDATE_PROJECT: "validateProject";
+    readonly GENERATE_OUTPUTS_BEGIN: "generateOutputsBegin";
+    readonly GENERATE_OUTPUTS_END: "generateOutputsEnd";
 };

package/dist/{lib → types}/application.d.ts

@@ -1,20 +1,20 @@
-import { Deserializer, Serializer } from "./serialization/index.js";
+import { type ProjectReflection } from "#models";
+import { AbstractComponent, type DocumentationEntryPoint, EntryPointStrategy, Options, type OptionsReader, type TypeDocOptions } from "#node-utils";
+import { Deserializer, Serializer } from "#serialization";
 import { Converter } from "./converter/index.js";
 import { Renderer } from "./output/renderer.js";
-import { type ProjectReflection } from "./models/index.js";
-import { AbstractComponent, type OptionsReader } from "./utils/index.js";
-import { Options } from "./utils/index.js";
-import { type TypeDocOptions } from "./utils/options/declaration.js";
+import { FileRegistry } from "#models";
 import { type GlobString, Logger } from "#utils";
-import { type DocumentationEntryPoint, EntryPointStrategy } from "./utils/entry-point.js";
-import { FileRegistry } from "./models/FileRegistry.js";
-import { Outputs } from "./output/output.js";
+import { RepositoryManager } from "./converter/utilities/repository.js";
 import { Internationalization } from "./internationalization/internationalization.js";
+import { Outputs } from "./output/output.js";
 export declare function createAppForTesting(): Application;
 export interface ApplicationEvents {
     bootstrapEnd: [Application];
     reviveProject: [ProjectReflection];
     validateProject: [ProjectReflection];
+    generateOutputsBegin: [ProjectReflection];
+    generateOutputsEnd: [ProjectReflection];
 }
 /**
  * The default TypeDoc main application class.
@@ -72,6 +72,13 @@ export declare class Application extends AbstractComponent<Application, Applicat
      * this was the wrong place for this member to live.
      */
     files: FileRegistry;
+    /**
+     * Cache of git repository information used by the SourcePlugin to get source URLs.
+     * Will be undefined before {@link convert} is called, will also be undefined if the
+     * `--disableSources` option is enabled.
+     * @internal
+     */
+    repositories: RepositoryManager | undefined;
     /** @internal */
     accessor lang: string;
     /** @internal */
@@ -87,18 +94,35 @@ export declare class Application extends AbstractComponent<Application, Applicat
     /**
      * Emitted after plugins have been loaded and options have been read, but before they have been frozen.
      * The listener will be given an instance of {@link Application}.
+     * @event
      */
     static readonly EVENT_BOOTSTRAP_END: "bootstrapEnd";
     /**
      * Emitted after a project has been deserialized from JSON.
      * The listener will be given an instance of {@link ProjectReflection}.
+     * @event
      */
     static readonly EVENT_PROJECT_REVIVE: "reviveProject";
     /**
      * Emitted when validation is being run.
      * The listener will be given an instance of {@link ProjectReflection}.
+     * @event
      */
     static readonly EVENT_VALIDATE_PROJECT: "validateProject";
+    /**
+     * Emitted just before outputs are generated. This can be used by plugins which generate
+     * additional auxiliary output files to avoid generating output if the user has validation
+     * warnings and treat warnings as errors is enabled.
+     * @event
+     */
+    static readonly EVENT_GENERATE_OUTPUTS_BEGIN: "generateOutputsBegin";
+    /**
+     * Emitted just after outputs are generated. This can be used by plugins which generate
+     * additional auxiliary output files to avoid generating output if the user has validation
+     * warnings and treat warnings as errors is enabled.
+     * @event
+     */
+    static readonly EVENT_GENERATE_OUTPUTS_END: "generateOutputsEnd";
     /**
      * Create a new TypeDoc application instance.
      */
@@ -120,6 +144,13 @@ export declare class Application extends AbstractComponent<Application, Applicat
      * @param readers Option readers to use to discover options from config files.
      */
     static bootstrap(options?: TypeDocOptions, readers?: readonly OptionsReader[]): Promise<Application>;
+    /**
+     * Internal utility to synchronously create an application instance.
+     * Only intended for TypeDoc's unit tests.
+     * @internal
+     * @private
+     */
+    static createAppForTesting(): Application;
     private _bootstrap;
     /** @internal */
     setOptions(options: TypeDocOptions, reportErrors?: boolean): boolean;
@@ -192,4 +223,16 @@ export declare class Application extends AbstractComponent<Application, Applicat
     toString(): string;
     private _convertPackages;
     private _merge;
+    /**
+     * Conversion is synchronous to ensure that TypeDoc builds are completely
+     * reproducible, so the SourcePlugin, which needs git information either needs
+     * to run commands synchronously or we need to initialize the repositories which
+     * are relevant before calling {@link Converter#convert}. As of v0.28.20, we do
+     * that initialization early.
+     *
+     * This generally does not need to be called manually as {@link convert} and
+     * {@link convertAndWatch} will automatically do it, but is exposed for API users
+     * who want to primarily run TypeDoc synchronously.
+     */
+    initializeRepositories(entryPoints: readonly DocumentationEntryPoint[]): Promise<void>;
 }

package/dist/{lib → types}/converter/comments/declarationReferenceResolver.d.ts

@@ -1,3 +1,3 @@
-import { type Reflection } from "../../models/index.js";
+import { type Reflection } from "#models";
 import type { DeclarationReference } from "#utils";
 export declare function resolveDeclarationReference(reflection: Reflection, ref: DeclarationReference): Reflection | undefined;

package/dist/{lib → types}/converter/comments/discovery.d.ts

@@ -1,7 +1,7 @@
-import ts from "typescript";
-import { ReflectionKind } from "../../models/index.js";
-import { CommentStyle } from "../../utils/options/declaration.js";
+import { ReflectionKind } from "#models";
+import { CommentStyle } from "#node-utils";
 import { type Logger } from "#utils";
+import ts from "typescript";
 export interface DiscoveredComment {
     file: ts.SourceFile;
     ranges: ts.CommentRange[];

package/dist/{lib → types}/converter/comments/index.d.ts

@@ -1,8 +1,8 @@
-import ts from "typescript";
-import { Comment, ReflectionKind } from "../../models/index.js";
-import type { CommentStyle, JsDocCompatibility, ValidationOptions } from "../../utils/options/declaration.js";
-import type { FileRegistry } from "../../models/FileRegistry.js";
+import type { FileRegistry } from "#models";
+import { Comment, ReflectionKind } from "#models";
+import type { CommentStyle, JsDocCompatibility, ValidationOptions } from "#node-utils";
 import { Logger } from "#utils";
+import ts from "typescript";
 import type { Context } from "../context.js";
 export interface CommentParserConfig {
     blockTags: Set<string>;

package/dist/{lib → types}/converter/comments/lexer.d.ts

@@ -1,4 +1,4 @@
-import type { ReflectionSymbolId } from "../../models/index.js";
+import type { ReflectionSymbolId } from "#models";
 export declare enum TokenSyntaxKind {
     Text = "text",
     NewLine = "new_line",

package/dist/{lib → types}/converter/comments/linkResolver.d.ts

@@ -1,4 +1,4 @@
-import { type CommentDisplayPart, Reflection, ReflectionSymbolId } from "../../models/index.js";
+import { type CommentDisplayPart, Reflection, ReflectionSymbolId } from "#models";
 import { type DeclarationReference } from "#utils";
 export type ExternalResolveResult = {
     target: string;

package/dist/{lib → types}/converter/comments/parser.d.ts

@@ -1,9 +1,8 @@
-import type { CommentContextOptionalChecker, CommentParserConfig } from "./index.js";
-import { Comment, type CommentDisplayPart } from "../../models/index.js";
+import { Comment, type CommentDisplayPart, FileRegistry } from "#models";
 import type { MinimalSourceFile } from "#utils";
-import { type Token } from "./lexer.js";
-import { FileRegistry } from "../../models/FileRegistry.js";
 import { type Logger } from "#utils";
+import type { CommentContextOptionalChecker, CommentParserConfig } from "./index.js";
+import { type Token } from "./lexer.js";
 export declare function parseComment(tokens: Generator<Token, undefined, undefined>, file: MinimalSourceFile, context: CommentContextOptionalChecker): Comment;
 /**
  * Intended for parsing markdown documents. This only parses code blocks and

package/dist/{lib → types}/converter/comments/textParser.d.ts

@@ -1,5 +1,11 @@
-import type { CommentDisplayPart } from "../../models/index.js";
-import type { FileRegistry } from "../../models/FileRegistry.js";
+/**
+ * Parser to handle plain text markdown.
+ *
+ * Responsible for recognizing relative paths within the text and turning
+ * them into references.
+ * @module
+ */
+import type { CommentDisplayPart, FileRegistry } from "#models";
 import { type ValidationOptions } from "#node-utils";
 import { type Token } from "./lexer.js";
 import type { NormalizedPath, TranslatedString } from "#utils";

package/dist/{lib → types}/converter/components.d.ts

@@ -1,4 +1,4 @@
-import { AbstractComponent } from "../utils/component.js";
+import { AbstractComponent } from "#node-utils";
 import type { Converter } from "./converter.js";
 export declare abstract class ConverterComponent extends AbstractComponent<Converter, {}> {
 }

package/dist/{lib → types}/converter/context.d.ts

@@ -1,5 +1,5 @@
 import ts from "typescript";
-import { Comment, DeclarationReflection, type DocumentReflection, type ProjectReflection, ReferenceType, type Reflection, ReflectionKind } from "../models/index.js";
+import { Comment, DeclarationReflection, type DocumentReflection, type ProjectReflection, ReferenceType, type Reflection, ReflectionKind } from "#models";
 import type { Converter } from "./converter.js";
 import { type NormalizedPath } from "#utils";
 /**
@@ -75,7 +75,7 @@ export declare class Context {
      * This is available on Context so that it can be monkey-patched by typedoc-plugin-missing-exports
      * It might also turn out to be generally useful for other plugin users.
      */
-    createSymbolId(symbol: ts.Symbol, declaration?: ts.Declaration): import("../models/ReflectionSymbolId.js").ReflectionSymbolId;
+    createSymbolId(symbol: ts.Symbol, declaration?: ts.Declaration): import("#models").ReflectionSymbolId;
     addChild(reflection: DeclarationReflection | DocumentReflection): void;
     shouldIgnore(symbol: ts.Symbol): boolean;
     /**

package/dist/{lib → types}/converter/converter.d.ts

@@ -1,15 +1,13 @@
 import ts from "typescript";
+import type { FileRegistry } from "#models";
+import { Comment, type CommentDisplayPart, type ContainerReflection, type DeclarationReflection, DocumentReflection, type ParameterReflection, ProjectReflection, Reflection, type ReflectionSymbolId, type SignatureReflection, type SomeType, type TypeParameterReflection } from "#models";
+import type { CommentStyle, DocumentationEntryPoint, ValidationOptions } from "#node-utils";
+import { AbstractComponent } from "#node-utils";
+import { type DeclarationReference, type GlobString, MinimalSourceFile } from "#utils";
 import type { Application } from "../application.js";
-import { Comment, type CommentDisplayPart, type ContainerReflection, type DeclarationReflection, DocumentReflection, type ParameterReflection, ProjectReflection, Reflection, type ReflectionSymbolId, type SignatureReflection, type SomeType, type TypeParameterReflection } from "../models/index.js";
-import { Context } from "./context.js";
-import { AbstractComponent } from "../utils/component.js";
-import { type GlobString, MinimalSourceFile } from "#utils";
-import type { DocumentationEntryPoint } from "../utils/entry-point.js";
 import { type CommentParserConfig } from "./comments/index.js";
-import type { CommentStyle, ValidationOptions } from "../utils/options/declaration.js";
 import { type ExternalResolveResult, type ExternalSymbolResolver } from "./comments/linkResolver.js";
-import { type DeclarationReference } from "#utils";
-import type { FileRegistry } from "../models/FileRegistry.js";
+import { Context } from "./context.js";
 import { IncludePlugin } from "./plugins/IncludePlugin.js";
 export interface ConverterEvents {
     begin: [Context];

package/dist/{lib → types}/converter/factories/signature.d.ts

@@ -1,5 +1,5 @@
 import ts from "typescript";
-import { ParameterReflection, type Reflection, ReflectionKind, SignatureReflection, TypeParameterReflection } from "../../models/index.js";
+import { ParameterReflection, type Reflection, ReflectionKind, SignatureReflection, TypeParameterReflection } from "#models";
 import type { Context } from "../context.js";
 export declare function convertConstructSignatures(context: Context, symbol: ts.Symbol): void;
 export declare function createSignature(context: Context, kind: ReflectionKind.CallSignature | ReflectionKind.ConstructorSignature | ReflectionKind.GetSignature | ReflectionKind.SetSignature, signature: ts.Signature, symbol: ts.Symbol | undefined, declaration?: ts.SignatureDeclaration | ts.JSDocSignature): void;

package/dist/{lib → types}/converter/index.d.ts

@@ -3,3 +3,4 @@ export type { ExternalResolveResult, ExternalSymbolResolver } from "./comments/l
 export { Context } from "./context.js";
 export { convertDefaultValue, convertExpression } from "./convert-expression.js";
 export { Converter, type ConverterEvents } from "./converter.js";
+export { RepositoryManager } from "./utilities/repository.ts";