@depup/typedoc 0.28.17-depup.0

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

@@ -0,0 +1,7 @@
+import ts from "typescript";
+export declare function isNamedNode(node: unknown): node is {
+    readonly 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;
+export declare function isTypeReference(type: ts.Type): type is ts.TypeReference;

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

@@ -0,0 +1,26 @@
+import ts from "typescript";
+export function isNamedNode(node) {
+    const name = node.name;
+    return !!name && (ts.isMemberName(name) || ts.isComputedPropertyName(name));
+}
+export function getHeritageTypes(declarations, kind) {
+    const exprs = declarations.flatMap((d) => (d.heritageClauses ?? [])
+        .filter((hc) => hc.token === kind)
+        .flatMap((hc) => hc.types));
+    const seenTexts = new Set();
+    return exprs.filter((expr) => {
+        const text = expr.getText();
+        if (seenTexts.has(text)) {
+            return false;
+        }
+        seenTexts.add(text);
+        return true;
+    });
+}
+export function isObjectType(type) {
+    return typeof type.objectFlags === "number";
+}
+export function isTypeReference(type) {
+    return (isObjectType(type) &&
+        (type.objectFlags & ts.ObjectFlags.Reference) !== 0);
+}

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

@@ -0,0 +1,2 @@
+import { type SomeType } from "../../models/index.js";
+export declare function removeUndefined(type: SomeType): SomeType;

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

@@ -0,0 +1,17 @@
+import { IntrinsicType, UnionType } from "../../models/index.js";
+export function removeUndefined(type) {
+    if (type instanceof UnionType) {
+        const types = type.types.filter((t) => {
+            if (t instanceof IntrinsicType) {
+                return t.name !== "undefined";
+            }
+            return true;
+        });
+        if (types.length === 1) {
+            return types[0];
+        }
+        type.types = types;
+        return type;
+    }
+    return type;
+}

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

@@ -0,0 +1,96 @@
+import { type Logger } from "#utils";
+export declare function gitIsInstalled(): boolean;
+export interface Repository {
+    readonly path: string;
+    getURL(fileName: string, line: number): string | undefined;
+}
+export declare class AssumedRepository implements Repository {
+    readonly path: string;
+    readonly gitRevision: string;
+    readonly sourceLinkTemplate: string;
+    constructor(path: string, gitRevision: string, sourceLinkTemplate: string);
+    getURL(fileName: string, line: number): string | undefined;
+}
+/**
+ * Stores data of a repository.
+ */
+export declare class GitRepository implements Repository {
+    /**
+     * The path of this repository on disk.
+     */
+    path: string;
+    /**
+     * All files tracked by the repository.
+     */
+    files: Set<string>;
+    urlTemplate: string;
+    gitRevision: string;
+    /**
+     * Create a new Repository instance.
+     *
+     * @param path  The root path of the repository.
+     */
+    constructor(path: string, gitRevision: string, urlTemplate: string);
+    /**
+     * Get the URL of the given file on GitHub or Bitbucket.
+     *
+     * @param fileName  The file whose URL should be determined.
+     * @returns A URL pointing to the web preview of the given file or undefined.
+     */
+    getURL(fileName: string, line: number): string | undefined;
+    /**
+     * Try to create a new repository instance.
+     *
+     * Checks whether the given path is the root of a valid repository and if so
+     * creates a new instance of {@link GitRepository}.
+     *
+     * @param path  The potential repository root.
+     * @returns A new instance of {@link GitRepository} or undefined.
+     */
+    static tryCreateRepository(path: string, sourceLinkTemplate: string, gitRevision: string, gitRemote: string, logger: Logger): GitRepository | undefined;
+}
+/**
+ * Responsible for keeping track of 0-N repositories which exist on a machine.
+ * This used to be inlined in SourcePlugin, moved out for easy unit testing.
+ *
+ * Git repositories can be nested. Files should be resolved to a repo as shown
+ * below:
+ * ```text
+ * /project
+ * /project/.git (A)
+ * /project/file.js (A)
+ * /project/folder/file.js (A)
+ * /project/sub/.git (B)
+ * /project/sub/file.js (B)
+ * ```
+ *
+ * In order words, it is not safe to assume that just because a file is within
+ * the `/project` directory, that it belongs to repo `A`. As calling git is
+ * expensive (~20-300ms depending on the machine, antivirus, etc.) we check for
+ * `.git` folders manually, and only call git if one is found.
+ *
+ * Symlinked files have the potential to further complicate this. If TypeScript's
+ * `preserveSymlinks` option is on, then this may be passed the path to a symlinked
+ * file. Unlike TypeScript, we will resolve the path, as the repo link should really
+ * point to the actual file.
+ */
+export declare class RepositoryManager {
+    private basePath;
+    private gitRevision;
+    private gitRemote;
+    private sourceLinkTemplate;
+    private disableGit;
+    private logger;
+    private cache;
+    private assumedRepo;
+    constructor(basePath: string, gitRevision: string, gitRemote: string, sourceLinkTemplate: string, disableGit: boolean, logger: Logger);
+    /**
+     * Check whether the given file is placed inside a repository.
+     *
+     * @param fileName  The name of the file a repository should be looked for.
+     * @returns The found repository info or undefined.
+     */
+    getRepository(fileName: string): Repository | undefined;
+    private getRepositoryFolder;
+}
+export declare function guessSourceUrlTemplate(remotes: string[]): string | undefined;

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

@@ -0,0 +1,295 @@
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+import { spawnSync } from "child_process";
+import { normalizePath } from "../../utils/index.js";
+import { i18n, NonEnumerable } from "#utils";
+import { dirname, join } from "path";
+import { existsSync } from "fs";
+const TEN_MEGABYTES = 1024 * 10000;
+function git(...args) {
+    return spawnSync("git", args, {
+        encoding: "utf-8",
+        windowsHide: true,
+        maxBuffer: TEN_MEGABYTES,
+    });
+}
+let haveGit;
+export function gitIsInstalled() {
+    haveGit ??= git("--version").status === 0;
+    return haveGit;
+}
+export class AssumedRepository {
+    path;
+    gitRevision;
+    sourceLinkTemplate;
+    constructor(path, gitRevision, sourceLinkTemplate) {
+        this.path = path;
+        this.gitRevision = gitRevision;
+        this.sourceLinkTemplate = sourceLinkTemplate;
+    }
+    getURL(fileName, line) {
+        const replacements = {
+            gitRevision: this.gitRevision,
+            "gitRevision:short": this.gitRevision.substring(0, 8),
+            path: fileName.substring(this.path.length + 1),
+            line,
+        };
+        return this.sourceLinkTemplate.replace(/\{(gitRevision|gitRevision:short|path|line)\}/g, (_, key) => replacements[key]);
+    }
+}
+/**
+ * Stores data of a repository.
+ */
+let GitRepository = (() => {
+    let _files_decorators;
+    let _files_initializers = [];
+    let _files_extraInitializers = [];
+    return class GitRepository {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _files_decorators = [NonEnumerable];
+            __esDecorate(null, null, _files_decorators, { kind: "field", name: "files", static: false, private: false, access: { has: obj => "files" in obj, get: obj => obj.files, set: (obj, value) => { obj.files = value; } }, metadata: _metadata }, _files_initializers, _files_extraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        /**
+         * The path of this repository on disk.
+         */
+        path;
+        /**
+         * All files tracked by the repository.
+         */
+        files = __runInitializers(this, _files_initializers, new Set());
+        urlTemplate = __runInitializers(this, _files_extraInitializers);
+        gitRevision;
+        /**
+         * Create a new Repository instance.
+         *
+         * @param path  The root path of the repository.
+         */
+        constructor(path, gitRevision, urlTemplate) {
+            this.path = path;
+            this.gitRevision = gitRevision;
+            this.urlTemplate = urlTemplate;
+            const out = git("-C", path, "ls-files", "-z");
+            if (out.status === 0) {
+                out.stdout.split("\0").forEach((file) => {
+                    if (file !== "") {
+                        this.files.add(normalizePath(path + "/" + file));
+                    }
+                });
+            }
+        }
+        /**
+         * Get the URL of the given file on GitHub or Bitbucket.
+         *
+         * @param fileName  The file whose URL should be determined.
+         * @returns A URL pointing to the web preview of the given file or undefined.
+         */
+        getURL(fileName, line) {
+            if (!this.files.has(fileName)) {
+                return;
+            }
+            const replacements = {
+                gitRevision: this.gitRevision,
+                "gitRevision:short": this.gitRevision.substring(0, 8),
+                path: fileName.substring(this.path.length + 1),
+                line,
+            };
+            return this.urlTemplate.replace(/\{(gitRevision|gitRevision:short|path|line)\}/g, (_, key) => replacements[key]);
+        }
+        /**
+         * Try to create a new repository instance.
+         *
+         * Checks whether the given path is the root of a valid repository and if so
+         * creates a new instance of {@link GitRepository}.
+         *
+         * @param path  The potential repository root.
+         * @returns A new instance of {@link GitRepository} or undefined.
+         */
+        static tryCreateRepository(path, sourceLinkTemplate, gitRevision, gitRemote, logger) {
+            if (gitRevision === "{branch}") {
+                gitRevision = git("-C", path, "branch", "--show-current").stdout.trim();
+            }
+            gitRevision ||= git("-C", path, "rev-parse", "HEAD").stdout.trim();
+            if (gitRevision == "HEAD")
+                return; // Will only happen in a repo with no commits.
+            let urlTemplate;
+            if (sourceLinkTemplate) {
+                urlTemplate = sourceLinkTemplate;
+            }
+            else {
+                const remotesOut = git("-C", path, "remote", "get-url", gitRemote);
+                if (remotesOut.status === 0) {
+                    urlTemplate = guessSourceUrlTemplate(remotesOut.stdout.split("\n"));
+                }
+                else {
+                    logger.warn(i18n.git_remote_0_not_valid(gitRemote));
+                }
+            }
+            if (!urlTemplate)
+                return;
+            return new GitRepository(normalizePath(path), gitRevision, urlTemplate);
+        }
+    };
+})();
+export { GitRepository };
+/**
+ * Responsible for keeping track of 0-N repositories which exist on a machine.
+ * This used to be inlined in SourcePlugin, moved out for easy unit testing.
+ *
+ * Git repositories can be nested. Files should be resolved to a repo as shown
+ * below:
+ * ```text
+ * /project
+ * /project/.git (A)
+ * /project/file.js (A)
+ * /project/folder/file.js (A)
+ * /project/sub/.git (B)
+ * /project/sub/file.js (B)
+ * ```
+ *
+ * In order words, it is not safe to assume that just because a file is within
+ * the `/project` directory, that it belongs to repo `A`. As calling git is
+ * expensive (~20-300ms depending on the machine, antivirus, etc.) we check for
+ * `.git` folders manually, and only call git if one is found.
+ *
+ * Symlinked files have the potential to further complicate this. If TypeScript's
+ * `preserveSymlinks` option is on, then this may be passed the path to a symlinked
+ * file. Unlike TypeScript, we will resolve the path, as the repo link should really
+ * point to the actual file.
+ */
+export class RepositoryManager {
+    basePath;
+    gitRevision;
+    gitRemote;
+    sourceLinkTemplate;
+    disableGit;
+    logger;
+    cache = new Map();
+    assumedRepo;
+    constructor(basePath, gitRevision, gitRemote, sourceLinkTemplate, disableGit, logger) {
+        this.basePath = basePath;
+        this.gitRevision = gitRevision;
+        this.gitRemote = gitRemote;
+        this.sourceLinkTemplate = sourceLinkTemplate;
+        this.disableGit = disableGit;
+        this.logger = logger;
+        this.assumedRepo = new AssumedRepository(this.basePath, this.gitRevision, this.sourceLinkTemplate);
+    }
+    /**
+     * Check whether the given file is placed inside a repository.
+     *
+     * @param fileName  The name of the file a repository should be looked for.
+     * @returns The found repository info or undefined.
+     */
+    getRepository(fileName) {
+        if (this.disableGit) {
+            return this.assumedRepo;
+        }
+        return this.getRepositoryFolder(normalizePath(dirname(fileName)));
+    }
+    getRepositoryFolder(dir) {
+        if (this.cache.has(dir)) {
+            return this.cache.get(dir);
+        }
+        if (existsSync(join(dir, ".git"))) {
+            // This might just be a git repo, or we might be in some self-recursive symlink
+            // loop, and the repo is actually somewhere else. Ask Git where the repo actually is.
+            const repo = git("-C", dir, "rev-parse", "--show-toplevel");
+            if (repo.status === 0) {
+                const repoDir = repo.stdout.replace("\n", "");
+                // This check is only necessary if we're in a symlink loop, otherwise
+                // it will always be true.
+                if (!this.cache.has(repoDir)) {
+                    this.cache.set(repoDir, GitRepository.tryCreateRepository(repoDir, this.sourceLinkTemplate, this.gitRevision, this.gitRemote, this.logger));
+                }
+                this.cache.set(dir, this.cache.get(repoDir));
+            }
+            else {
+                // Not a git repo, probably corrupt.
+                this.cache.set(dir, undefined);
+            }
+        }
+        else {
+            // We may be at the root of the file system, in which case there is no repo.
+            this.cache.set(dir, undefined);
+            this.cache.set(dir, this.getRepositoryFolder(dirname(dir)));
+        }
+        return this.cache.get(dir);
+    }
+}
+// Should have three capturing groups:
+// 1. hostname
+// 2. user
+// 3. project
+const repoExpressions = [
+    /(github(?!.us)(?:\.[a-z]+)*\.[a-z]{2,})[:/]([^/]+)\/(.*)/,
+    /(\w+\.githubprivate.com)[:/]([^/]+)\/(.*)/, // GitHub enterprise
+    /(\w+\.ghe.com)[:/]([^/]+)\/(.*)/, // GitHub enterprise
+    /(\w+\.github.us)[:/]([^/]+)\/(.*)/, // GitHub enterprise
+    /(bitbucket.org)[:/]([^/]+)\/(.*)/,
+    /(gitlab.com)[:/]([^/]+)\/(.*)/,
+];
+export function guessSourceUrlTemplate(remotes) {
+    let hostname = "";
+    let user = "";
+    let project = "";
+    outer: for (const repoLink of remotes) {
+        for (const regex of repoExpressions) {
+            const match = regex.exec(repoLink);
+            if (match) {
+                hostname = match[1];
+                user = match[2];
+                project = match[3];
+                break outer;
+            }
+        }
+    }
+    if (!hostname)
+        return;
+    if (project.endsWith(".git")) {
+        project = project.slice(0, -4);
+    }
+    let sourcePath = "blob";
+    let anchorPrefix = "L";
+    if (hostname.includes("gitlab")) {
+        sourcePath = "-/blob";
+    }
+    else if (hostname.includes("bitbucket")) {
+        sourcePath = "src";
+        anchorPrefix = "lines-";
+    }
+    return `https://${hostname}/${user}/${project}/${sourcePath}/{gitRevision}/{path}#${anchorPrefix}{line}`;
+}

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

@@ -0,0 +1,2 @@
+import ts from "typescript";
+export declare function resolveAliasedSymbol(symbol: ts.Symbol, checker: ts.TypeChecker): ts.Symbol;

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

@@ -0,0 +1,12 @@
+import ts from "typescript";
+export function resolveAliasedSymbol(symbol, checker) {
+    const seen = new Set();
+    while (ts.SymbolFlags.Alias & symbol.flags) {
+        symbol = checker.getAliasedSymbol(symbol);
+        // #2438, with declaration files, we might have an aliased symbol which eventually points to itself.
+        if (seen.has(symbol))
+            return symbol;
+        seen.add(symbol);
+    }
+    return symbol;
+}

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

@@ -0,0 +1,2 @@
+export { debugReflectionLifetimes } from "./reflectionLifetimes.js";
+export { debugRendererUrls } from "./rendererUrls.js";

package/dist/lib/debug/index.js

@@ -0,0 +1,2 @@
+export { debugReflectionLifetimes } from "./reflectionLifetimes.js";
+export { debugRendererUrls } from "./rendererUrls.js";

package/dist/lib/debug/reflectionLifetimes.d.ts

@@ -0,0 +1,3 @@
+import type { Application } from "../application.js";
+export declare function debugReflectionLifetimes(app: Application, kindFilter?: number): void;
+export declare function load(app: Application): void;

package/dist/lib/debug/reflectionLifetimes.js

@@ -0,0 +1,27 @@
+import { ConverterEvents } from "../converter/converter-events.js";
+import { ReflectionKind } from "../models/index.js";
+export function debugReflectionLifetimes(app, kindFilter = ReflectionKind.All) {
+    app.converter.on(ConverterEvents.CREATE_PROJECT, logCreate);
+    app.converter.on(ConverterEvents.CREATE_SIGNATURE, logCreate);
+    app.converter.on(ConverterEvents.CREATE_TYPE_PARAMETER, logCreate);
+    app.converter.on(ConverterEvents.CREATE_DECLARATION, logCreate);
+    app.converter.on(ConverterEvents.CREATE_DOCUMENT, logCreate);
+    app.converter.on(ConverterEvents.CREATE_PARAMETER, logCreate);
+    app.converter.on(ConverterEvents.CREATE_PROJECT, (_context, project) => {
+        const oldRemove = project["_removeReflection"];
+        project["_removeReflection"] = function (reflection) {
+            if (reflection.kindOf(kindFilter)) {
+                console.log("Remove", reflection.id, reflection.getFullName());
+            }
+            return oldRemove.call(this, reflection);
+        };
+    });
+    function logCreate(_context, refl) {
+        if (refl.kindOf(kindFilter)) {
+            console.log("Create", refl.variant, refl.id, refl.getFullName());
+        }
+    }
+}
+export function load(app) {
+    debugReflectionLifetimes(app);
+}

package/dist/lib/debug/rendererUrls.d.ts

@@ -0,0 +1,6 @@
+import type { Application } from "../application.js";
+export declare function debugRendererUrls(app: Application, { json, logs }?: {
+    logs?: true;
+    json?: boolean | undefined;
+}): void;
+export declare function load(app: Application): void;

package/dist/lib/debug/rendererUrls.js

@@ -0,0 +1,68 @@
+/* eslint-disable no-console */
+import { join } from "node:path";
+import { Reflection, ReflectionKind } from "../models/index.js";
+function makeSerializer(router) {
+    const serializer = {
+        priority: 0,
+        supports(x) {
+            return x instanceof Reflection;
+        },
+        toObject(item, obj) {
+            if (router.hasUrl(item)) {
+                obj.url = router.getFullUrl(item);
+                obj.hasOwnDocument = router.hasOwnDocument(item);
+            }
+            delete obj.sources;
+            delete obj.groups;
+            delete obj.categories;
+            delete obj.readme;
+            delete obj.content;
+            obj.kind = ReflectionKind[obj.kind];
+            delete obj.flags;
+            delete obj.defaultValue;
+            delete obj.symbolIdMap;
+            delete obj.files;
+            delete obj.packageName;
+            delete obj.variant;
+            delete obj.extendedTypes;
+            delete obj.inheritedFrom;
+            if (!["reflection", "reference"].includes(obj.type?.type)) {
+                delete obj.type;
+            }
+            if (obj.comment) {
+                obj.comment.summary = obj.comment.summary.filter((part) => part.kind === "inline-tag");
+                obj.comment.blockTags = obj.comment.blockTags?.filter((tag) => {
+                    tag.content = tag.content.filter((part) => part.kind === "inline-tag");
+                    return tag.content.length;
+                });
+                if (!obj.comment.summary.length &&
+                    !obj.comment.blockTags?.length &&
+                    !obj.comment.modifierTags) {
+                    delete obj.comment;
+                }
+            }
+            return obj;
+        },
+    };
+    return serializer;
+}
+export function debugRendererUrls(app, { json = false, logs = false } = { logs: true }) {
+    app.renderer.postRenderAsyncJobs.push(async (evt) => {
+        const router = app.renderer.router;
+        if (json) {
+            const serializer = makeSerializer(router);
+            app.serializer.addSerializer(serializer);
+            await app.generateJson(evt.project, join(evt.outputDirectory, "url_debug.json"));
+            app.serializer.removeSerializer(serializer);
+        }
+        if (logs) {
+            for (const id in evt.project.reflections) {
+                const refl = evt.project.reflections[id];
+                console.log(refl.id, refl.getFullName(), router.hasUrl(refl) ? router.getFullUrl(refl) : undefined);
+            }
+        }
+    });
+}
+export function load(app) {
+    debugRendererUrls(app);
+}

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

@@ -0,0 +1,7 @@
+/**
+ * Internationalization module for localized strings in output.
+ * @summary Internationalization module for localized strings in output.
+ * @module
+ */
+export { i18n, type TranslatedString } from "#utils";
+export { Internationalization, type TranslatableStrings, type TranslationProxy } from "./internationalization.js";

package/dist/lib/internationalization/index.js

@@ -0,0 +1,7 @@
+/**
+ * Internationalization module for localized strings in output.
+ * @summary Internationalization module for localized strings in output.
+ * @module
+ */
+export { i18n } from "#utils";
+export { Internationalization } from "./internationalization.js";

package/dist/lib/internationalization/internationalization.d.ts

@@ -0,0 +1,65 @@
+import { type TranslatedString } from "#utils";
+import { type BuiltinTranslatableStringArgs } from "./translatable.js";
+/**
+ * ### What is translatable?
+ * TypeDoc includes a lot of literal strings. By convention, messages which are displayed
+ * to the user at the INFO level or above should be present in this object to be available
+ * for translation. Messages at the VERBOSE level need not be translated as they are primarily
+ * intended for debugging. ERROR/WARNING deprecation messages related to TypeDoc's API, or
+ * requesting users submit a bug report need not be translated.
+ *
+ * Errors thrown by TypeDoc are generally *not* considered translatable as they are not
+ * displayed to the user. An exception to this is errors thrown by the `validate` method
+ * on options, as option readers will use them to report errors to the user.
+ *
+ * ### Interface Keys
+ * This object uses a similar convention as TypeScript, where the specified key should
+ * indicate where placeholders are present by including a number in the name. This is
+ * so that translations can easily tell that they are including the appropriate placeholders.
+ * This will also be validated at runtime by the {@link Internationalization} class, but
+ * it's better to have that hint when editing as well.
+ *
+ * This interface defines the available translatable strings, and the number of placeholders
+ * that are required to use each string. Plugins may use declaration merging to add members
+ * to this interface to use TypeDoc's internationalization module.
+ *
+ * @example
+ * ```ts
+ * declare module "typedoc" {
+ *     interface TranslatableStrings {
+ *         // Define a translatable string with no arguments
+ *         plugin_msg: [];
+ *         // Define a translatable string requiring one argument
+ *         plugin_msg_0: [string];
+ *     }
+ * }
+ * ```
+ */
+export interface TranslatableStrings extends BuiltinTranslatableStringArgs {
+}
+/**
+ * Dynamic proxy type built from {@link TranslatableStrings}
+ */
+export type TranslationProxy = {
+    [K in keyof TranslatableStrings]: (...args: TranslatableStrings[K]) => TranslatedString;
+};
+/**
+ * Load TypeDoc's translations for a specified language
+ */
+export declare function loadTranslations(lang: string): Record<string, string>;
+/**
+ * Get languages which TypeDoc includes translations for
+ */
+export declare function getNativelySupportedLanguages(): string[];
+/**
+ * Responsible for maintaining loaded internationalized strings.
+ */
+export declare class Internationalization {
+    private locales;
+    private loadedLocale;
+    constructor();
+    setLocale(locale: string): void;
+    addTranslations(locale: string, translations: Record<string, string>): void;
+    hasTranslations(locale: string): boolean;
+    getSupportedLanguages(): string[];
+}