@depup/typedoc 0.28.17-depup.0

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

@@ -0,0 +1,284 @@
+import { Comment, Reflection, ReflectionKind, } from "../../../../models/index.js";
+import { assert, i18n, JSX } from "#utils";
+import { classNames, getKindClass } from "../../lib.js";
+import { anchorTargetIfPresent } from "./anchor-icon.js";
+function renderingTypeDetailsIsUseful(container, type, notRenderedTags) {
+    const isUsefulVisitor = {
+        array(type) {
+            return renderingTypeDetailsIsUseful(container, type.elementType, notRenderedTags);
+        },
+        intersection(type) {
+            return type.types.some(t => renderingTypeDetailsIsUseful(container, t, notRenderedTags));
+        },
+        union(type) {
+            return !!type.elementSummaries ||
+                type.types.some(t => renderingTypeDetailsIsUseful(container, t, notRenderedTags));
+        },
+        reflection(type) {
+            return renderingChildIsUseful(type.declaration, notRenderedTags);
+        },
+        reference(type) {
+            return shouldExpandReference(container, type);
+        },
+    };
+    return type.visit(isUsefulVisitor) ?? false;
+}
+export function typeDeclaration(context, reflectionOwningType, type) {
+    assert(reflectionOwningType instanceof Reflection, "typeDeclaration(reflectionOwningType, type) called incorrectly");
+    if (renderingTypeDetailsIsUseful(reflectionOwningType, type, context.options.getValue("notRenderedTags"))) {
+        return (JSX.createElement("div", { class: "tsd-type-declaration" },
+            JSX.createElement("h4", null, i18n.theme_type_declaration()),
+            context.typeDetails(reflectionOwningType, type, true)));
+    }
+    return null;
+}
+const expandTypeCache = new WeakMap();
+function getExpandTypeInfo(refl) {
+    const cache = expandTypeCache.get(refl);
+    if (cache)
+        return cache;
+    const expandType = new Set();
+    const preventExpand = new Set();
+    if (!refl.isProject()) {
+        const info = getExpandTypeInfo(refl.parent);
+        for (const item of info.expandType) {
+            expandType.add(item);
+        }
+        for (const item of info.preventExpand) {
+            preventExpand.add(item);
+        }
+    }
+    for (const tag of refl.comment?.blockTags || []) {
+        if (tag.tag === "@expandType") {
+            const name = Comment.combineDisplayParts(tag.content);
+            expandType.add(name);
+            preventExpand.delete(name);
+        }
+        else if (tag.tag === "@preventExpand") {
+            const name = Comment.combineDisplayParts(tag.content);
+            preventExpand.add(name);
+            expandType.delete(name);
+        }
+    }
+    expandTypeCache.set(refl, { expandType, preventExpand });
+    return { expandType, preventExpand };
+}
+const expanded = new Set();
+function shouldExpandReference(container, reference) {
+    const target = reference.reflection;
+    if (!target) {
+        // If it doesn't exist, expand only if there are specific properties
+        // which the user annotated. Assume they know what they're doing.
+        return reference.highlightedProperties !== undefined;
+    }
+    // Prevent expansion of non-types
+    if (!target.kindOf(ReflectionKind.TypeAlias | ReflectionKind.Interface))
+        return false;
+    // Prevent recursive expand
+    if (expanded.has(target))
+        return false;
+    const info = getExpandTypeInfo(container);
+    // Expand if the user explicitly requested it with @param or @expand
+    if (reference.highlightedProperties || target.comment?.hasModifier("@expand") || info.expandType.has(target.name)) {
+        return !info.preventExpand.has(target.name);
+    }
+    return false;
+}
+export function typeDetails(context, reflectionOwningType, type, renderAnchors) {
+    return typeDetailsImpl(context, reflectionOwningType, type, renderAnchors);
+}
+export function typeDetailsImpl(context, reflectionOwningType, type, renderAnchors, highlighted) {
+    const result = type.visit({
+        array(type) {
+            return context.typeDetails(reflectionOwningType, type.elementType, renderAnchors);
+        },
+        intersection(type) {
+            return type.types.map((t) => context.typeDetails(reflectionOwningType, t, renderAnchors));
+        },
+        union(type) {
+            const result = [];
+            for (let i = 0; i < type.types.length; ++i) {
+                result.push(JSX.createElement("li", null,
+                    context.type(type.types[i]),
+                    context.displayParts(type.elementSummaries?.[i]),
+                    context.typeDetailsIfUseful(reflectionOwningType, type.types[i])));
+            }
+            return JSX.createElement("ul", null, result);
+        },
+        reflection(type) {
+            const declaration = type.declaration;
+            if (highlighted) {
+                return highlightedDeclarationDetails(context, declaration, renderAnchors, highlighted);
+            }
+            return declarationDetails(context, declaration, renderAnchors);
+        },
+        reference(reference) {
+            if (shouldExpandReference(reflectionOwningType, reference)) {
+                const target = reference.reflection;
+                if (!target?.isDeclaration()) {
+                    return highlightedPropertyDetails(context, reference.highlightedProperties);
+                }
+                // Ensure we don't go into an infinite loop here
+                expanded.add(target);
+                const details = target.type
+                    ? context.typeDetails(reflectionOwningType, target.type, renderAnchors)
+                    : declarationDetails(context, target, renderAnchors);
+                expanded.delete(target);
+                return details;
+            }
+        },
+        // tuple??
+    });
+    if (!result && highlighted) {
+        return highlightedPropertyDetails(context, highlighted);
+    }
+    return result;
+}
+export function typeDetailsIfUseful(context, reflectionOwningType, type) {
+    assert(reflectionOwningType instanceof Reflection, "typeDetailsIfUseful(reflectionOwningType, type) called incorrectly");
+    if (type && renderingTypeDetailsIsUseful(reflectionOwningType, type, context.options.getValue("notRenderedTags"))) {
+        return context.typeDetails(reflectionOwningType, type, false);
+    }
+}
+function highlightedPropertyDetails(context, highlighted) {
+    if (!highlighted?.size)
+        return;
+    return (JSX.createElement("ul", { class: "tsd-parameters" }, Array.from(highlighted.entries(), ([name, parts]) => {
+        return (JSX.createElement("li", { class: "tsd-parameter" },
+            JSX.createElement("h5", null,
+                JSX.createElement("span", null, name)),
+            context.displayParts(parts)));
+    })));
+}
+function highlightedDeclarationDetails(context, declaration, renderAnchors, highlightedProperties) {
+    return (JSX.createElement("ul", { class: "tsd-parameters" }, declaration
+        .getProperties()
+        ?.map((child) => highlightedProperties?.has(child.name) &&
+        renderChild(context, child, renderAnchors, highlightedProperties.get(child.name)))));
+}
+function declarationDetails(context, declaration, renderAnchors) {
+    return (JSX.createElement(JSX.Fragment, null,
+        context.commentSummary(declaration),
+        JSX.createElement("ul", { class: "tsd-parameters" },
+            declaration.signatures && (JSX.createElement("li", { class: "tsd-parameter-signature" },
+                JSX.createElement("ul", { class: classNames({ "tsd-signatures": true }, context.getReflectionClasses(declaration)) }, declaration.signatures.map((item) => {
+                    const anchor = context.router.hasUrl(item) ? context.getAnchor(item) : undefined;
+                    return (JSX.createElement(JSX.Fragment, null,
+                        JSX.createElement("li", { class: "tsd-signature", id: anchor }, context.memberSignatureTitle(item, {
+                            hideName: true,
+                        })),
+                        JSX.createElement("li", { class: "tsd-description" }, context.memberSignatureBody(item, {
+                            hideSources: true,
+                        }))));
+                })))),
+            declaration.indexSignatures?.map((index) => renderIndexSignature(context, index)),
+            declaration.getProperties()?.map((child) => renderChild(context, child, renderAnchors)))));
+}
+function renderChild(context, child, renderAnchors, highlight) {
+    if (child.signatures) {
+        return (JSX.createElement("li", { class: "tsd-parameter" },
+            JSX.createElement("h5", { id: anchorTargetIfPresent(context, child) },
+                child.flags.isRest && JSX.createElement("span", { class: "tsd-signature-symbol" }, "..."),
+                JSX.createElement("span", { class: getKindClass(child) }, child.name),
+                JSX.createElement("span", { class: "tsd-signature-symbol" },
+                    child.flags.isOptional && "?",
+                    ":"),
+                " function"),
+            context.memberSignatures(child)));
+    }
+    function highlightOrComment(refl) {
+        if (highlight) {
+            return context.displayParts(highlight);
+        }
+        return (JSX.createElement(JSX.Fragment, null,
+            context.commentSummary(refl),
+            context.commentTags(refl)));
+    }
+    // standard type
+    if (child.type) {
+        const notRenderedTags = context.options.getValue("notRenderedTags");
+        return (JSX.createElement("li", { class: "tsd-parameter" },
+            JSX.createElement("h5", { id: anchorTargetIfPresent(context, child) },
+                context.reflectionFlags(child),
+                child.flags.isRest && JSX.createElement("span", { class: "tsd-signature-symbol" }, "..."),
+                JSX.createElement("span", { class: getKindClass(child) }, child.name),
+                JSX.createElement("span", { class: "tsd-signature-symbol" },
+                    child.flags.isOptional && "?",
+                    ": "),
+                context.type(child.type)),
+            highlightOrComment(child),
+            child.getProperties().some(prop => renderingChildIsUseful(prop, notRenderedTags)) && (JSX.createElement("ul", { class: "tsd-parameters" }, child.getProperties().map((c) => renderChild(context, c, renderAnchors))))));
+    }
+    // getter/setter
+    return (JSX.createElement(JSX.Fragment, null,
+        child.getSignature && (JSX.createElement("li", { class: "tsd-parameter" },
+            JSX.createElement("h5", { id: anchorTargetIfPresent(context, child) },
+                context.reflectionFlags(child.getSignature),
+                JSX.createElement("span", { class: "tsd-signature-keyword" }, "get"),
+                " ",
+                JSX.createElement("span", { class: getKindClass(child) }, child.name),
+                JSX.createElement("span", { class: "tsd-signature-symbol" }, "():"),
+                " ",
+                context.type(child.getSignature.type)),
+            highlightOrComment(child.getSignature))),
+        child.setSignature && (JSX.createElement("li", { class: "tsd-parameter" },
+            JSX.createElement("h5", { id: !child.getSignature ? anchorTargetIfPresent(context, child) : undefined },
+                context.reflectionFlags(child.setSignature),
+                JSX.createElement("span", { class: "tsd-signature-keyword" }, "set"),
+                " ",
+                JSX.createElement("span", { class: getKindClass(child) }, child.name),
+                JSX.createElement("span", { class: "tsd-signature-symbol" }, "("),
+                child.setSignature.parameters?.map((item) => (JSX.createElement(JSX.Fragment, null,
+                    item.name,
+                    JSX.createElement("span", { class: "tsd-signature-symbol" }, ":"),
+                    " ",
+                    context.type(item.type)))),
+                JSX.createElement("span", { class: "tsd-signature-symbol" }, "):"),
+                " ",
+                context.type(child.setSignature.type)),
+            highlightOrComment(child.setSignature)))));
+}
+function renderIndexSignature(context, index) {
+    return (JSX.createElement("li", { class: "tsd-parameter-index-signature" },
+        JSX.createElement("h5", null,
+            index.flags.isReadonly && (JSX.createElement(JSX.Fragment, null,
+                JSX.createElement("span", { class: "tsd-signature-keyword" }, "readonly"),
+                " ")),
+            JSX.createElement("span", { class: "tsd-signature-symbol" }, "["),
+            index.parameters.map((item) => (JSX.createElement(JSX.Fragment, null,
+                JSX.createElement("span", { class: getKindClass(item) }, item.name),
+                ": ",
+                context.type(item.type)))),
+            JSX.createElement("span", { class: "tsd-signature-symbol" }, "]:"),
+            " ",
+            context.type(index.type)),
+        context.commentSummary(index),
+        context.commentTags(index),
+        context.typeDeclaration(index, index.type)));
+}
+function renderingChildIsUseful(refl, notRenderedTags) {
+    // Object types directly under a variable/type alias will always be considered useful.
+    // This probably isn't ideal, but it is an easy thing to check when assigning URLs
+    // in the default theme, so we'll make the assumption that those properties ought to always
+    // be rendered.
+    // This should be kept in sync with the DefaultTheme.applyAnchorUrl function.
+    if (refl.kindOf(ReflectionKind.TypeLiteral) &&
+        refl.parent?.kindOf(ReflectionKind.SomeExport) &&
+        refl.parent.type?.type === "reflection") {
+        return true;
+    }
+    if (renderingThisChildIsUseful(refl, notRenderedTags)) {
+        return true;
+    }
+    return refl.getProperties().some(prop => renderingThisChildIsUseful(prop, notRenderedTags));
+}
+function renderingThisChildIsUseful(refl, notRenderedTags) {
+    if (refl.hasComment(notRenderedTags))
+        return true;
+    const declaration = refl.type?.type === "reflection" ? refl.type.declaration : refl;
+    if (declaration.hasComment(notRenderedTags))
+        return true;
+    return declaration.getAllSignatures().some((sig) => {
+        return sig.hasComment(notRenderedTags) || sig.parameters?.some((p) => p.hasComment(notRenderedTags));
+    });
+}

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

@@ -0,0 +1,4 @@
+import type { DefaultThemeRenderContext } from "../DefaultThemeRenderContext.js";
+import type { TypeParameterReflection } from "../../../../models/index.js";
+import { JSX } from "#utils";
+export declare function typeParameters(context: DefaultThemeRenderContext, typeParameters: TypeParameterReflection[]): JSX.Element;

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

@@ -0,0 +1,26 @@
+import { i18n, JSX } from "#utils";
+import { anchorTargetIfPresent } from "./anchor-icon.js";
+export function typeParameters(context, typeParameters) {
+    return (JSX.createElement(JSX.Fragment, null,
+        JSX.createElement("section", { class: "tsd-panel" },
+            JSX.createElement("h4", null, i18n.kind_plural_type_parameter()),
+            JSX.createElement("ul", { class: "tsd-type-parameter-list" }, typeParameters.map((item) => (JSX.createElement("li", null,
+                JSX.createElement("span", { id: anchorTargetIfPresent(context, item) },
+                    item.flags.isConst && (JSX.createElement(JSX.Fragment, null,
+                        JSX.createElement("span", { class: "tsd-signature-keyword" }, "const"),
+                        " ")),
+                    item.varianceModifier && (JSX.createElement(JSX.Fragment, null,
+                        JSX.createElement("span", { class: "tsd-signature-keyword" }, item.varianceModifier),
+                        " ")),
+                    JSX.createElement("span", { class: "tsd-kind-type-parameter" }, item.name),
+                    !!item.type && (JSX.createElement(JSX.Fragment, null,
+                        " ",
+                        JSX.createElement("span", { class: "tsd-signature-keyword" }, "extends"),
+                        " ",
+                        context.type(item.type))),
+                    !!item.default && (JSX.createElement(JSX.Fragment, null,
+                        " = ",
+                        context.type(item.default)))),
+                context.commentSummary(item),
+                context.commentTags(item))))))));
+}

package/dist/lib/output/themes/default/templates/document.d.ts

@@ -0,0 +1,5 @@
+import type { DefaultThemeRenderContext } from "../DefaultThemeRenderContext.js";
+import type { DocumentReflection } from "../../../../models/index.js";
+import type { PageEvent } from "../../../events.js";
+import { JSX } from "#utils";
+export declare const documentTemplate: ({ markdown }: DefaultThemeRenderContext, props: PageEvent<DocumentReflection>) => JSX.Element;

package/dist/lib/output/themes/default/templates/document.js

@@ -0,0 +1,3 @@
+import { JSX } from "#utils";
+export const documentTemplate = ({ markdown }, props) => (JSX.createElement("div", { class: "tsd-panel tsd-typography" },
+    JSX.createElement(JSX.Raw, { html: markdown(props.model.content) })));

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

@@ -0,0 +1,5 @@
+import type { DefaultThemeRenderContext } from "../DefaultThemeRenderContext.js";
+import type { PageEvent } from "../../../events.js";
+import { JSX } from "#utils";
+import type { ProjectReflection } from "../../../../models/index.js";
+export declare function hierarchyTemplate(context: DefaultThemeRenderContext, props: PageEvent<ProjectReflection>): JSX.Element;

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

@@ -0,0 +1,31 @@
+import { i18n, JSX } from "#utils";
+import { getHierarchyRoots } from "../../lib.js";
+function fullHierarchy(context, root, seen) {
+    if (seen.has(root)) {
+        return (JSX.createElement("li", { "data-refl": root.id },
+            JSX.createElement("a", { href: context.urlTo(root) },
+                context.reflectionIcon(root),
+                root.name)));
+    }
+    seen.add(root);
+    const children = [];
+    for (const child of [...(root.implementedBy || []), ...(root.extendedBy || [])]) {
+        if (child.reflection) {
+            children.push(fullHierarchy(context, child.reflection, seen));
+        }
+    }
+    // Note: We don't use root.anchor for the anchor, because those are built on a per page basis.
+    // And classes/interfaces get their own page, so all the anchors will be empty anyways.
+    // Full name should be safe here, since this list only includes classes/interfaces.
+    return (JSX.createElement("li", { "data-refl": root.id, id: root.getFullName() },
+        JSX.createElement("a", { href: context.urlTo(root) },
+            context.reflectionIcon(root),
+            root.name),
+        !!children.length && JSX.createElement("ul", null, children)));
+}
+export function hierarchyTemplate(context, props) {
+    const seen = new Set();
+    return (JSX.createElement(JSX.Fragment, null,
+        JSX.createElement("h2", null, i18n.theme_hierarchy_summary()),
+        getHierarchyRoots(props.project).map((root) => (JSX.createElement("ul", { class: "tsd-full-hierarchy" }, fullHierarchy(context, root, seen))))));
+}

package/dist/lib/output/themes/default/templates/index.d.ts

@@ -0,0 +1,5 @@
+import type { DefaultThemeRenderContext } from "../DefaultThemeRenderContext.js";
+import type { ProjectReflection } from "../../../../models/index.js";
+import type { PageEvent } from "../../../events.js";
+import { JSX } from "#utils";
+export declare const indexTemplate: ({ markdown }: DefaultThemeRenderContext, props: PageEvent<ProjectReflection>) => JSX.Element;

package/dist/lib/output/themes/default/templates/index.js

@@ -0,0 +1,3 @@
+import { JSX } from "#utils";
+export const indexTemplate = ({ markdown }, props) => (JSX.createElement("div", { class: "tsd-panel tsd-typography" },
+    JSX.createElement(JSX.Raw, { html: markdown(props.model.readme || []) })));

package/dist/lib/output/themes/default/templates/reflection.d.ts

@@ -0,0 +1,5 @@
+import type { DefaultThemeRenderContext } from "../DefaultThemeRenderContext.js";
+import type { PageEvent } from "../../../events.js";
+import { type ContainerReflection } from "../../../../models/index.js";
+import { JSX } from "#utils";
+export declare function reflectionTemplate(context: DefaultThemeRenderContext, props: PageEvent<ContainerReflection>): JSX.Element;

package/dist/lib/output/themes/default/templates/reflection.js

@@ -0,0 +1,53 @@
+import { classNames, getKindClass, hasTypeParameters } from "../../lib.js";
+import { DeclarationReflection, ReflectionKind, } from "../../../../models/index.js";
+import { i18n, JSX } from "#utils";
+export function reflectionTemplate(context, props) {
+    if (props.model.kindOf(ReflectionKind.TypeAlias | ReflectionKind.Variable) &&
+        props.model instanceof DeclarationReflection &&
+        props.model.type) {
+        return context.memberDeclaration(props.model);
+    }
+    if (props.model.kindOf(ReflectionKind.ExportContainer) &&
+        (props.model.isDeclaration() || props.model.isProject())) {
+        return context.moduleReflection(props.model);
+    }
+    return (JSX.createElement(JSX.Fragment, null,
+        props.model.hasComment(context.options.getValue("notRenderedTags")) && (JSX.createElement("section", { class: "tsd-panel tsd-comment" },
+            context.commentSummary(props.model),
+            context.commentTags(props.model))),
+        context.reflectionPreview(props.model),
+        hasTypeParameters(props.model) && JSX.createElement(JSX.Fragment, null, context.typeParameters(props.model.typeParameters)),
+        props.model instanceof DeclarationReflection && (JSX.createElement(JSX.Fragment, null,
+            context.hierarchy(props.model.typeHierarchy),
+            !!props.model.implementedTypes && (JSX.createElement("section", { class: "tsd-panel" },
+                JSX.createElement("h4", null, i18n.theme_implements()),
+                JSX.createElement("ul", { class: "tsd-hierarchy" }, props.model.implementedTypes.map((item) => JSX.createElement("li", null, context.type(item)))))),
+            !!props.model.implementedBy && (JSX.createElement("section", { class: "tsd-panel" },
+                JSX.createElement("h4", null, i18n.theme_implemented_by()),
+                JSX.createElement("ul", { class: "tsd-hierarchy" }, props.model.implementedBy.map((item) => JSX.createElement("li", null, context.type(item)))))),
+            !!props.model.signatures?.length && (JSX.createElement("section", { class: "tsd-panel" }, context.memberSignatures(props.model))),
+            !!props.model.indexSignatures?.length && (JSX.createElement("section", { class: "tsd-panel" },
+                JSX.createElement("h4", { class: "tsd-before-signature" }, i18n.theme_indexable()),
+                JSX.createElement("ul", { class: "tsd-signatures" }, props.model.indexSignatures.map((index) => renderIndexSignature(context, index))))),
+            !props.model.signatures && context.memberSources(props.model))),
+        !!props.model.childrenIncludingDocuments?.length && context.index(props.model),
+        context.members(props.model)));
+}
+function renderIndexSignature(context, index) {
+    return (JSX.createElement("li", { class: classNames({ "tsd-index-signature": true }, context.getReflectionClasses(index)) },
+        JSX.createElement("div", { class: "tsd-signature" },
+            index.flags.isReadonly && (JSX.createElement(JSX.Fragment, null,
+                JSX.createElement("span", { class: "tsd-signature-keyword" }, "readonly"),
+                " ")),
+            JSX.createElement("span", { class: "tsd-signature-symbol" }, "["),
+            index.parameters.map((item) => (JSX.createElement(JSX.Fragment, null,
+                JSX.createElement("span", { class: getKindClass(item) }, item.name),
+                ": ",
+                context.type(item.type)))),
+            JSX.createElement("span", { class: "tsd-signature-symbol" }, "]:"),
+            " ",
+            context.type(index.type)),
+        context.commentSummary(index),
+        context.commentTags(index),
+        context.typeDetailsIfUseful(index, index.type)));
+}

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

@@ -0,0 +1,44 @@
+import type { DefaultThemeRenderContext } from "../index.js";
+import { type CommentDisplayPart, type ContainerReflection, DeclarationReflection, type DocumentReflection, ProjectReflection, type Reflection, type TypeParameterReflection } from "../../models/index.js";
+import { JSX } from "#utils";
+export declare function stringify(data: unknown): string;
+export declare function getDisplayName(refl: Reflection): string;
+export declare function toStyleClass(str: string): string;
+export declare function getKindClass(refl: Reflection): string;
+/**
+ * Insert word break tags ``<wbr>`` into the given string.
+ *
+ * Breaks the given string at ``_``, ``-`` and capital letters.
+ *
+ * @param str The string that should be split.
+ * @return The original string containing ``<wbr>`` tags where possible.
+ */
+export declare function wbr(str: string): (string | JSX.Element)[];
+export declare function join<T>(joiner: JSX.Children, list: readonly T[], cb: (x: T) => JSX.Children): JSX.Element;
+export declare function classNames(names: Record<string, boolean | null | undefined>, extraCss?: string): string | undefined;
+export declare function hasTypeParameters(reflection: Reflection): reflection is Reflection & {
+    typeParameters: TypeParameterReflection[];
+};
+export declare function renderTypeParametersSignature(context: DefaultThemeRenderContext, typeParameters: readonly TypeParameterReflection[] | undefined): JSX.Element;
+/**
+ * Renders the reflection name with an additional `?` if optional.
+ */
+export declare function renderName(refl: Reflection): JSX.Element | (string | JSX.Element)[];
+export declare function getHierarchyRoots(project: ProjectReflection): DeclarationReflection[];
+export declare function isNoneSection(section: MemberSection): boolean;
+export interface MemberSection {
+    title: string;
+    description?: CommentDisplayPart[];
+    children: Array<DocumentReflection | DeclarationReflection>;
+}
+export declare function getMemberSections(parent: ContainerReflection, childFilter?: (refl: Reflection) => boolean): MemberSection[];
+/**
+ * Returns a (hopefully) globally unique path for the given reflection.
+ *
+ * This only works for exportable symbols, so e.g. methods are not affected by this.
+ *
+ * If the given reflection has a globally unique name already, then it will be returned as is. If the name is
+ * ambiguous (i.e. there are two classes with the same name in different namespaces), then the namespaces path of the
+ * reflection will be returned.
+ */
+export declare function getUniquePath(reflection: Reflection): Reflection[];