typedoc

typedoc

Version 0.28.13
Published 1 day ago
2.14 MB
5 dependencies
Apache-2.0 license

Install

npm i typedoc

yarn add typedoc

pnpm add typedoc

Overview

Create api documentation for TypeScript projects.

Index

Variables

variable CommentStyle

const CommentStyle: {
    readonly JSDoc: 'jsdoc';
    readonly Block: 'block';
    readonly Line: 'line';
    readonly All: 'all';
};

Determines how TypeDoc searches for comments.

variable EntryPointStrategy

const EntryPointStrategy: {
    readonly Resolve: 'resolve';
    readonly Expand: 'expand';
    readonly Packages: 'packages';
    readonly Merge: 'merge';
};

Defines how entry points are interpreted.

variable PageKind

const PageKind: {
    readonly Index: 'index';
    readonly Reflection: 'reflection';
    readonly Document: 'document';
    readonly Hierarchy: 'hierarchy';
};

The type of page which should be rendered. This may be extended in the future.
Note: TypeDoc any string may be used as the page kind. TypeDoc defines a few described by this object.

variable TypeContext

const TypeContext: {
    readonly none: 'none';
    readonly templateLiteralElement: 'templateLiteralElement';
    readonly arrayElement: 'arrayElement';
    readonly indexedAccessElement: 'indexedAccessElement';
    readonly conditionalCheck: 'conditionalCheck';
    readonly conditionalExtends: 'conditionalExtends';
    readonly conditionalTrue: 'conditionalTrue';
    readonly conditionalFalse: 'conditionalFalse';
    readonly indexedIndex: 'indexedIndex';
    readonly indexedObject: 'indexedObject';
    readonly inferredConstraint: 'inferredConstraint';
    readonly intersectionElement: 'intersectionElement';
    readonly mappedName: 'mappedName';
    readonly mappedParameter: 'mappedParameter';
    readonly mappedTemplate: 'mappedTemplate';
    readonly optionalElement: 'optionalElement';
    readonly predicateTarget: 'predicateTarget';
    readonly queryTypeTarget: 'queryTypeTarget';
    readonly typeOperatorTarget: 'typeOperatorTarget';
    readonly referenceTypeArgument: 'referenceTypeArgument';
    readonly restElement: 'restElement';
    readonly tupleElement: 'tupleElement';
    readonly unionElement: 'unionElement';
};

Enumeration that can be used when traversing types to track the location of recursion. Used by TypeDoc internally to track when to output parenthesis when rendering.

variable VarianceModifier

const VarianceModifier: {
    readonly in: 'in';
    readonly out: 'out';
    readonly inOut: 'in out';
};

Modifier flags for type parameters, added in TS 4.7

Functions

function makeRecursiveVisitor

makeRecursiveVisitor: (visitor: Partial<TypeVisitor>) => TypeVisitor;

function normalizePath

normalizePath: (path: string) => NormalizedPath;

Normalize the given path.
Parameter path
The path that should be normalized.
Returns
The normalized path.

function Option

Option: <K extends keyof TypeDocOptionMap>(
    name: K
) => (
    _: unknown,
    _context: ClassAccessorDecoratorContext<
        { application: Application } | { options: Options },
        TypeDocOptionValues[K]
    >
) => {
    get(
        this: { application: Application } | { options: Options }
    ): TypeDocOptionValues[K];
    set(_value: never): never;
};

Binds an option to an accessor. Does not register the option.
Note: This is a standard ES decorator. It will not work with pre-TS 5.0 experimental decorators enabled.

function resetReflectionID

resetReflectionID: () => void;

Reset the reflection id.
Used by the test cases to ensure the reflection ids won't change between runs.

function splitUnquotedString

splitUnquotedString: (input: string, delimiter: string) => string[];

Classes

class Application

class Application extends AbstractComponent<Application, ApplicationEvents> {}

The default TypeDoc main application class.
This class holds the two main components of TypeDoc, the Converter and the Renderer. When running TypeDoc, first the Converter is invoked which generates a ProjectReflection from the passed in source files. The ProjectReflection is a hierarchical model representation of the TypeScript project. Afterwards the model is passed to the Renderer which uses an instance of Theme to generate the final documentation.
Both the Converter and the Renderer emit a series of events while processing the project. Subscribe to these Events to control the application flow or alter the output.
Remarks
Access to an Application instance can be retrieved with Application.bootstrap or Application.bootstrapWithPlugins. It can not be constructed manually.
None Root level class which contains most useful behavior.

property converter

converter: Converter;

The converter used to create the declaration reflections.

property deserializer

deserializer: Deserializer;

The deserializer used to restore previously serialized JSON output.

property entryPoints

entryPoints: GlobString[];

property entryPointStrategy

entryPointStrategy: EntryPointStrategy;

property EVENT_BOOTSTRAP_END

static readonly EVENT_BOOTSTRAP_END: string;

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 Application.

property EVENT_PROJECT_REVIVE

static readonly EVENT_PROJECT_REVIVE: string;

Emitted after a project has been deserialized from JSON. The listener will be given an instance of ProjectReflection.

property EVENT_VALIDATE_PROJECT

static readonly EVENT_VALIDATE_PROJECT: string;

Emitted when validation is being run. The listener will be given an instance of ProjectReflection.

property files

files: FileRegistry;

Due for deprecation in 0.29, use the reference to this on ProjectReflection, this was the wrong place for this member to live.

property internationalization

internationalization: Internationalization;

Internationalization module which supports translating according to the lang option.

property lang

lang: string;

property logger

logger: Logger;

The logger that should be used to output messages.

property options

options: Options;

property outputs

outputs: Outputs;

property renderer

renderer: Renderer;

The renderer used to generate the HTML documentation output.

property serializer

serializer: Serializer;

The serializer used to generate JSON output.

property skipErrorChecking

skipErrorChecking: boolean;

property VERSION

static readonly VERSION: string;

The version number of TypeDoc.

method bootstrap

static bootstrap: (
    options?: TypeDocOptions,
    readers?: readonly OptionsReader[]
) => Promise<Application>;

Initialize TypeDoc without loading plugins.
Parameter options
Options to set during initialization
Parameter readers
Option readers to use to discover options from config files.
Example 1
Initialize the application with pretty-printing output disabled.
const app = await Application.bootstrap({ pretty: false });

method bootstrapWithPlugins

static bootstrapWithPlugins: (
    options?: TypeDocOptions,
    readers?: readonly OptionsReader[]
) => Promise<Application>;

Initialize TypeDoc, loading plugins if applicable.

method convert

convert: () => Promise<ProjectReflection | undefined>;

Run the converter for the given set of files and return the generated reflections.
Returns
An instance of ProjectReflection on success, undefined otherwise.

method convertAndWatch

convertAndWatch: (
    success: (project: ProjectReflection) => Promise<void>
) => Promise<boolean>;

Run a convert / watch process.
Parameter success
Callback to run after each convert, receiving the project
Returns
True if the watch process should be restarted due to a configuration change, false for an options error

method generateDocs

generateDocs: (project: ProjectReflection, out: string) => Promise<void>;

Render HTML for the given project

method generateJson

generateJson: (project: ProjectReflection, out: string) => Promise<void>;

Write the reflections to a json file.
Parameter out
The path and file name of the target file.
Returns
Whether the JSON file could be written successfully.

method generateOutputs

generateOutputs: (project: ProjectReflection) => Promise<void>;

Render outputs selected with options for the specified project

method getDefinedEntryPoints

getDefinedEntryPoints: () => DocumentationEntryPoint[] | undefined;

Gets the entry points to be documented according to the current entryPoints and entryPointStrategy options. May return undefined if entry points fail to be expanded.

method getEntryPoints

getEntryPoints: () => DocumentationEntryPoint[] | undefined;

method getTypeScriptPath

getTypeScriptPath: () => string;

Return the path to the TypeScript compiler.

method getTypeScriptVersion

getTypeScriptVersion: () => string;

method toString

toString: () => string;

Print the version number.

method validate

validate: (project: ProjectReflection) => void;

method watchFile

watchFile: (path: string, shouldRestart?: boolean) => void;

Register that the current build depends on a file, so that in watch mode the build will be repeated. Has no effect if a watch build is not running, or if the file has already been registered.
Parameter path
The file to watch. It does not need to exist, and you should in fact register files you look for, but which do not exist, so that if they are created the build will re-run. (e.g. if you look through a list of 5 possibilities and find the third, you should register the first 3.)
Parameter shouldRestart
Should the build be completely restarted? (This is normally only used for configuration files -- i.e. files whose contents determine how conversion, rendering, or compiling will be done, as opposed to files that are only read *during* the conversion or rendering.)

class ArgumentsReader

class ArgumentsReader implements OptionsReader {}

Obtains option values from command-line arguments

constructor

constructor(priority: number, args?: string[]);

property name

readonly name: string;

property order

readonly order: number;

property supportsPackages

readonly supportsPackages: boolean;

method ignoreErrors

ignoreErrors: () => this;

method read

read: (container: Options, logger: Logger) => void;

class ArrayType

class ArrayType extends Type {}

Represents an array type.
let value: string[];
Types

constructor

constructor(elementType: SomeType);

Parameter elementType
The type of the elements in the array.

property elementType

elementType: SomeType;

property type

readonly type: string;

method getTypeString

protected getTypeString: () => string;

method needsParenthesis

needsParenthesis: () => boolean;

method toObject

toObject: (serializer: Serializer) => JSONOutput.ArrayType;

class BaseRouter

abstract class BaseRouter implements Router {}

Base router class intended to make it easier to implement a router.
Child classes need only getIdealBaseName, this class will take care of the recursing through child reflections. Routers

constructor

constructor(application: Application);

property accessor

protected accessor: any;

property accessor

protected accessor: any;

property anchors

protected anchors: Map<RouterTarget, string>;

property application

readonly application: Application;

property extension

extension: string;

property fullUrls

protected fullUrls: Map<RouterTarget, string>;

property includeHierarchySummary

includeHierarchySummary: boolean;

property sluggerConfiguration

sluggerConfiguration: { lowercase: boolean };

property sluggers

protected sluggers: Map<RouterTarget, Slugger>;

property usedFileNames

protected usedFileNames: Set<string>;

method baseRelativeUrl

baseRelativeUrl: (from: RouterTarget, target: string) => string;

method buildAnchors

protected buildAnchors: (target: RouterTarget, pageTarget: RouterTarget) => void;

method buildChildPages

protected buildChildPages: (
    target: RouterTarget,
    outPages: PageDefinition[]
) => void;

method buildPages

buildPages: (project: ProjectReflection) => PageDefinition[];

method getAnchor

getAnchor: (target: RouterTarget) => string | undefined;

method getFileName

protected getFileName: (baseName: string) => string;

method getFullUrl

getFullUrl: (target: RouterTarget) => string;

method getIdealBaseName

protected abstract getIdealBaseName: (reflection: RouterTarget) => string;

Should return the base-relative desired file name for a router target. This name may not be used exactly as TypeDoc will detect conflicts and automatically introduce a unique identifier to the URL to resolve them.

method getLinkTargets

getLinkTargets: () => RouterTarget[];

method getPageKind

protected getPageKind: (target: RouterTarget) => PageKind | undefined;

Should the page kind to use if a reflection should have its own rendered page in the output. Note that once undefined is returned, children of that reflection will not have their own document.

method getSlugger

getSlugger: (target: RouterTarget) => Slugger;

method getUrlSafeName

protected getUrlSafeName: (name: string) => string;

Strip non-url safe characters from the specified string.

method hasOwnDocument

hasOwnDocument: (target: RouterTarget) => boolean;

method hasUrl

hasUrl: (target: RouterTarget) => boolean;

method relativeUrl

relativeUrl: (from: RouterTarget, to: RouterTarget) => string;

class CategoryRouter

class CategoryRouter extends BaseRouter {}

Router which places reflections in folders according to @category tags. Routers

property defaultCategory

defaultCategory: any;

method getIdealBaseName

protected getIdealBaseName: (reflection: Reflection) => string;

class Comment

class Comment {}

A model that represents a comment.
Instances of this model are created by the CommentPlugin. You can retrieve comments through the DeclarationReflection.comment property. Comments

constructor

constructor(
    summary?: CommentDisplayPart[],
    blockTags?: CommentTag[],
    modifierTags?: Set<TagString>
);

Creates a new Comment instance.

property blockTags

blockTags: CommentTag[];

All associated block level tags.

property inheritedFromParentDeclaration

inheritedFromParentDeclaration?: boolean;

If the comment was inherited from a different "parent" declaration (see #2545), then it is desirable to know this as any @param tags which do not apply should not cause warnings. This is not serialized, and only set when the comment was created from a ts.CommentRange.

property label

label?: string;

Label associated with this reflection, if any (https://tsdoc.org/pages/tags/label/)

property modifierTags

modifierTags: Set<TagString>;

All modifier tags present on the comment, e.g. @alpha, @beta.

property sourcePath

sourcePath?: NormalizedPath;

Full path to the file where this comment originated from, if any. This field will not be serialized, so will not be present when handling JSON-revived reflections.
Note: This field is non-enumerable to make testing comment contents with deepEqual easier.

property summary

summary: CommentDisplayPart[];

The content of the comment which is not associated with a block tag.

method clone

clone: () => Comment;

Create a deep clone of this comment.

method cloneDisplayParts

static cloneDisplayParts: (
    parts: readonly CommentDisplayPart[]
) => CommentDisplayPart[];

Helper utility to clone Comment.summary or CommentTag.content

method combineDisplayParts

static combineDisplayParts: (
    parts: readonly CommentDisplayPart[] | undefined
) => string;

Debugging utility for combining parts into a simple string. Not suitable for rendering, but can be useful in tests.

method deserializeDisplayParts

static deserializeDisplayParts: (
    de: Deserializer,
    parts: JSONOutput.CommentDisplayPart[]
) => CommentDisplayPart[];

method fromObject

fromObject: (de: Deserializer, obj: JSONOutput.Comment) => void;

method getIdentifiedTag

getIdentifiedTag: (
    identifier: string,
    tagName: TagString
) => CommentTag | undefined;

method getShortSummary

getShortSummary: (useFirstParagraph: boolean) => readonly CommentDisplayPart[];

Gets either the @summary tag, or a short version of the comment summary section for rendering in module/namespace pages.

method getTag

getTag: (tagName: TagString) => CommentTag | undefined;

Return the first tag with the given name.
Parameter tagName
The name of the tag to look for.
Returns
The found tag or undefined.

method getTags

getTags: (tagName: TagString) => CommentTag[];

Get all tags with the given tag name.

method hasModifier

hasModifier: (tagName: TagString) => boolean;

Test whether this comment contains a tag with the given name.
Parameter tagName
The name of the tag to look for.
Returns
TRUE when this comment contains a tag with the given name, otherwise FALSE.

method hasVisibleComponent

hasVisibleComponent: (notRenderedTags?: readonly TagString[]) => boolean;

Checks if this comment contains any visible text.
Returns
TRUE when this reflection has a visible comment.

method removeModifier

removeModifier: (tagName: TagString) => void;

method removeTags

removeTags: (tagName: TagString) => void;

Removes all block tags with the given tag name from the comment.
Parameter tagName

method serializeDisplayParts

static serializeDisplayParts: {
    (parts: CommentDisplayPart[]): JSONOutput.CommentDisplayPart[];
    (parts: CommentDisplayPart[]): JSONOutput.CommentDisplayPart[];
};

no point in showing this signature in api docs

method similarTo

similarTo: (other: Comment) => boolean;

Checks if this comment is roughly equal to the other comment. This isn't exactly equal, but just "roughly equal" by the comment text.

method splitPartsToHeaderAndBody

static splitPartsToHeaderAndBody: (parts: readonly CommentDisplayPart[]) => {
    header: string;
    body: CommentDisplayPart[];
};

Splits the provided parts into a header (first line, as a string) and body (remaining lines). If the header line contains inline tags they will be serialized to a string.

method toObject

toObject: (serializer: Serializer) => JSONOutput.Comment;

class CommentTag

class CommentTag {}

A model that represents a single TypeDoc comment tag.
Tags are stored in the Comment.blockTags property. Comments

constructor

constructor(tag: TagString, text: CommentDisplayPart[]);

Create a new CommentTag instance.

property content

content: CommentDisplayPart[];

The actual body text of this tag.

property name

name?: string;

Some tags, (@typedef, @param, @property, etc.) may have a user defined identifier associated with them. If this tag is one of those, it will be parsed out and included here.

property skipRendering

skipRendering: boolean;

A flag which may be set by plugins to prevent TypeDoc from rendering this tag, if the plugin provides custom rendering. Note: This flag is **not** serialized, it is expected to be set just before the comment is rendered.

property tag

tag: TagString;

The name of this tag, e.g. @returns, @example

method clone

clone: () => CommentTag;

method fromObject

fromObject: (de: Deserializer, obj: JSONOutput.CommentTag) => void;

method similarTo

similarTo: (other: CommentTag) => boolean;

Checks if this block tag is roughly equal to the other tag. This isn't exactly equal, but just "roughly equal" by the tag text.

method toObject

toObject: () => JSONOutput.CommentTag;

class ConditionalType

class ConditionalType extends Type {}

Represents a conditional type.

let value: Check extends Extends ? True : False;

Types

constructor

constructor(
    checkType: SomeType,
    extendsType: SomeType,
    trueType: SomeType,
    falseType: SomeType
);

property checkType

checkType: SomeType;

property extendsType

extendsType: SomeType;

property falseType

falseType: SomeType;

property trueType

trueType: SomeType;

property type

readonly type: string;

method getTypeString

protected getTypeString: () => string;

method needsParenthesis

needsParenthesis: (context: TypeContext) => boolean;

method toObject

toObject: (serializer: Serializer) => JSONOutput.ConditionalType;

class ContainerReflection

abstract class ContainerReflection extends Reflection {}

Reflections

property categories

categories?: ReflectionCategory[];

All children grouped by their category.

property children

children?: DeclarationReflection[];

The children of this reflection. Do not add reflections to this array manually. Instead call addChild.

property childrenIncludingDocuments

childrenIncludingDocuments?: (DeclarationReflection | DocumentReflection)[];

Union of the children and documents arrays which dictates the sort order for rendering.

property documents

documents?: DocumentReflection[];

Documents associated with this reflection.
These are not children as including them as children requires code handle both types, despite being mostly unrelated and handled separately.
Including them here in a separate array neatly handles that problem, but also introduces another one for rendering. When rendering, documents should really actually be considered part of the "children" of a reflection. For this reason, we also maintain a list of child declarations with child documents which is used when rendering.

property groups

groups?: ReflectionGroup[];

All children grouped by their kind.

method addChild

addChild: (child: Reflection) => void;

method fromObject

fromObject: (de: Deserializer, obj: JSONOutput.ContainerReflection) => void;

method getChildrenByKind

getChildrenByKind: (kind: ReflectionKind) => DeclarationReflection[];

Return a list of all children of a certain kind.
Parameter kind
The desired kind of children.
Returns
An array containing all children with the desired kind.

method isContainer

isContainer: () => this is ContainerReflection;

method removeChild

removeChild: (child: DeclarationReflection | DocumentReflection) => void;

method toObject

toObject: (serializer: Serializer) => JSONOutput.ContainerReflection;

method traverse

traverse: (callback: TraverseCallback) => void;

class Context

class Context {}

The context describes the current state the converter is in.

property checker

readonly checker: ts.TypeChecker;

The TypeChecker instance returned by the TypeScript compiler.

property converter

readonly converter: Converter;

The converter instance that has created the context.

property convertingClassOrInterface

convertingClassOrInterface: boolean;

property convertingTypeNode

convertingTypeNode: boolean;

property inlineType

inlineType: Set<string>;

property preventInline

preventInline: Set<string>;

property program

readonly program: ts.Program;

The program currently being converted. Accessing this property will throw if a source file is not currently being converted.

property programs

readonly programs: readonly ts.Program[];

All programs being converted.

property project

readonly project: ProjectReflection;

The project that is currently processed.

property scope

readonly scope: Reflection;

The scope or parent reflection that is currently processed.

property shouldBeStatic

shouldBeStatic: boolean;

method addChild

addChild: (reflection: DeclarationReflection | DocumentReflection) => void;

method createDeclarationReflection

createDeclarationReflection: (
    kind: ReflectionKind,
    symbol: ts.Symbol | undefined,
    exportSymbol: ts.Symbol | undefined,
    nameOverride?: string
) => DeclarationReflection;

method createSymbolId

createSymbolId: (
    symbol: ts.Symbol,
    declaration?: ts.Declaration
) => import('../models/ReflectionSymbolId.js').ReflectionSymbolId;

Create a stable ReflectionSymbolId for the provided symbol, optionally targeting a specific declaration.

method createSymbolReference

createSymbolReference: (
    symbol: ts.Symbol,
    context: Context,
    name?: string
) => ReferenceType;

Create a ReferenceType which points to the provided symbol.

method expectSymbolAtLocation

expectSymbolAtLocation: (node: ts.Node) => ts.Symbol;

method finalizeDeclarationReflection

finalizeDeclarationReflection: (reflection: DeclarationReflection) => void;

method getComment

getComment: (symbol: ts.Symbol, kind: ReflectionKind) => Comment | undefined;

method getFileComment

getFileComment: (node: ts.SourceFile) => Comment | undefined;

method getJsDocComment

getJsDocComment: (
    declaration:
        | ts.JSDocPropertyLikeTag
        | ts.JSDocCallbackTag
        | ts.JSDocTypedefTag
        | ts.JSDocTemplateTag
        | ts.JSDocEnumTag
) => Comment | undefined;

method getNodeComment

getNodeComment: (node: ts.Node, moduleComment: boolean) => Comment | undefined;

method getReflectionFromSymbol

getReflectionFromSymbol: (symbol: ts.Symbol) => Reflection | undefined;

method getSignatureComment

getSignatureComment: (
    declaration: ts.SignatureDeclaration | ts.JSDocSignature
) => Comment | undefined;

method getSymbolAtLocation

getSymbolAtLocation: (node: ts.Node) => ts.Symbol | undefined;

method getSymbolFromReflection

getSymbolFromReflection: (reflection: Reflection) => ts.Symbol | undefined;

method getTypeAtLocation

getTypeAtLocation: (node: ts.Node) => ts.Type | undefined;

Return the type declaration of the given node.
Parameter node
The TypeScript node whose type should be resolved.
Returns
The type declaration of the given node.

method postReflectionCreation

postReflectionCreation: (
    reflection: Reflection,
    symbol: ts.Symbol | undefined,
    exportSymbol: ts.Symbol | undefined
) => void;

method registerReflection

registerReflection: (
    reflection: Reflection,
    symbol: ts.Symbol | undefined,
    filePath?: NormalizedPath
) => void;

Register a newly generated reflection. All created reflections should be passed to this method to ensure that the project helper functions work correctly.
Parameter reflection
The reflection that should be registered.
Parameter symbol
The symbol the given reflection was resolved from.

method resolveAliasedSymbol

resolveAliasedSymbol: (symbol: ts.Symbol) => ts.Symbol;

method shouldIgnore

shouldIgnore: (symbol: ts.Symbol) => boolean;

method shouldInline

shouldInline: (symbol: ts.Symbol, name: string) => boolean;

method withScope

withScope: (scope: Reflection) => Context;

class Converter

class Converter extends AbstractComponent<Application, ConverterEvents> {}

Compiles source files using TypeScript and converts compiler symbols to reflections.
None Responsible for converting TypeScript symbols into Reflections and Types.

constructor

constructor(owner: Application);

property commentStyle

commentStyle: CommentStyle;

property config

readonly config: CommentParserConfig;

property EVENT_BEGIN

static readonly EVENT_BEGIN: string;

Triggered when the converter begins converting a project. The listener will be given a Context object.

property EVENT_CREATE_DECLARATION

static readonly EVENT_CREATE_DECLARATION: string;

Triggered when the converter has created a declaration reflection. The listener will be given Context and a Models.DeclarationReflection.

property EVENT_CREATE_DOCUMENT

static readonly EVENT_CREATE_DOCUMENT: string;

Triggered when the converter has created a document reflection. The listener will be given undefined (for consistency with the other create events) and a Models.DocumentReflection.

property EVENT_CREATE_PARAMETER

static readonly EVENT_CREATE_PARAMETER: string;

Triggered when the converter has created a parameter reflection. The listener will be given Context, Models.ParameterReflection and a ts.Node?

property EVENT_CREATE_PROJECT

static readonly EVENT_CREATE_PROJECT: string;

Triggered when the converter has created a project reflection. The listener will be given Context and a Models.ProjectReflection.

property EVENT_CREATE_SIGNATURE

static readonly EVENT_CREATE_SIGNATURE: string;

Triggered when the converter has created a signature reflection. The listener will be given Context, Models.SignatureReflection | Models.ProjectReflection the declaration, ts.SignatureDeclaration | ts.IndexSignatureDeclaration | ts.JSDocSignature | undefined, and ts.Signature | undefined. The signature will be undefined if the created signature is an index signature.

property EVENT_CREATE_TYPE_PARAMETER

static readonly EVENT_CREATE_TYPE_PARAMETER: string;

Triggered when the converter has created a type parameter reflection. The listener will be given Context and a Models.TypeParameterReflection

property EVENT_END

static readonly EVENT_END: string;

Triggered when the converter has finished converting a project. The listener will be given a Context object.

property EVENT_RESOLVE

static readonly EVENT_RESOLVE: string;

Triggered when the converter resolves a reflection. The listener will be given Context and a Reflection.

property EVENT_RESOLVE_BEGIN

static readonly EVENT_RESOLVE_BEGIN: string;

Triggered when the converter begins resolving a project. The listener will be given Context.

property EVENT_RESOLVE_END

static readonly EVENT_RESOLVE_END: string;

Triggered when the converter has finished resolving a project. The listener will be given Context.

property excludeExternals

excludeExternals: boolean;

property excludePrivate

excludePrivate: boolean;

property excludeProtected

excludeProtected: boolean;

property excludeReferences

excludeReferences: boolean;

property externalPattern

externalPattern: GlobString[];

property externalSymbolLinkMappings

externalSymbolLinkMappings: Record<string, Record<string, string>>;

property maxTypeConversionDepth

maxTypeConversionDepth: number;

property preserveLinkText

preserveLinkText: boolean;

property validation

validation: ValidationOptions;

method addUnknownSymbolResolver

addUnknownSymbolResolver: (resolver: ExternalSymbolResolver) => void;

Adds a new resolver that the theme can use to try to figure out how to link to a symbol declared by a third-party library which is not included in the documentation.
The resolver function will be passed a declaration reference which it can attempt to resolve. If resolution fails, the function should return undefined.
Note: This will be used for both references to types declared in node_modules (in which case the reference passed will have the moduleSource set and the symbolReference will navigate via .) and user defined {@link} tags which cannot be resolved. If the link being resolved is inferred from a type, then no part will be passed to the resolver function.

method convert

convert: (entryPoints: readonly DocumentationEntryPoint[]) => ProjectReflection;

Compile the given source files and create a project reflection for them.

method deferConversion

deferConversion: (cb: () => void) => void;

Defer a conversion step until later. This may only be called during conversion. 0.28.0

method finalizeDeferredConversion

finalizeDeferredConversion: () => void;

Finalize deferred conversion, must be called by the caller of permitDeferredConversion 0.28.1

method parseRawComment

parseRawComment: (
    file: MinimalSourceFile,
    files: FileRegistry
) => { content: CommentDisplayPart[]; frontmatter: Record<string, unknown> };

Parse the given file into a comment. Intended to be used with markdown files.

method permitDeferredConversion

permitDeferredConversion: () => void;

Permit deferred conversion steps to take place. Until this is called, deferConversion will throw if used. 0.28.1

method processDocumentTags

processDocumentTags: (
    reflection: Reflection,
    parent: ContainerReflection
) => void;

method resolveLinks

resolveLinks: {
    (reflection: Reflection): void;
    (comment: Comment, owner: Reflection): void;
    (
        parts: readonly CommentDisplayPart[],
        owner: Reflection
    ): CommentDisplayPart[];
};

Deprecated
just pass the reflection

class DeclarationReflection

class DeclarationReflection extends ContainerReflection {}

A reflection that represents a single declaration emitted by the TypeScript compiler.
All parts of a project are represented by DeclarationReflection instances. The actual kind of a reflection is stored in its kind member. Reflections

property defaultValue

defaultValue?: string;

The default value of this reflection.
Applies to function parameters, variables, and properties.

property extendedBy

extendedBy?: ReferenceType[];

A list of all types that extend this reflection (e.g. the subclasses).

property extendedTypes

extendedTypes?: SomeType[];

A list of all types this reflection extends (e.g. the parent classes).

property getSignature

getSignature?: SignatureReflection;

The get signature of this declaration.

property implementationOf

implementationOf?: ReferenceType;

A type that points to the reflection this reflection is the implementation of.
Applies to class members.

property implementedBy

implementedBy?: ReferenceType[];

A list of all types that implement this reflection.

property implementedTypes

implementedTypes?: SomeType[];

A list of all types this reflection implements.

property indexSignatures

indexSignatures?: SignatureReflection[];

The index signature of this declaration.

property inheritedFrom

inheritedFrom?: ReferenceType;

A type that points to the reflection this reflection has been inherited from.
Applies to interface and class members.

property overwrites

overwrites?: ReferenceType;

A type that points to the reflection that has been overwritten by this reflection.
Applies to interface and class members.

property packageVersion

packageVersion?: string;

The version of the module when found.

property readme

readme?: CommentDisplayPart[];

The contents of the readme file of the module when found.

property setSignature

setSignature?: SignatureReflection;

The set signature of this declaration.

property signatures

signatures?: SignatureReflection[];

A list of call signatures attached to this declaration.
TypeDoc creates one declaration per function that may contain one or more signature reflections.

property sources

sources?: SourceReference[];

A list of all source files that contributed to this reflection.

property type

type?: SomeType;

The type of the reflection.
If the reflection represents a variable or a property, this is the value type. If the reflection represents a signature, this is the return type.

property typeHierarchy

typeHierarchy?: DeclarationHierarchy;

Contains a simplified representation of the type hierarchy suitable for being rendered in templates.

property typeParameters

typeParameters?: TypeParameterReflection[];

property variant

readonly variant: 'reference' | 'declaration';

method fromObject

fromObject: (
    de: Deserializer,
    obj: JSONOutput.DeclarationReflection | JSONOutput.ProjectReflection
) => void;

method getAllSignatures

getAllSignatures: () => SignatureReflection[];

method getChildOrTypePropertyByName

getChildOrTypePropertyByName: (
    path: string[]
) => DeclarationReflection | undefined;

method getNonIndexSignatures

getNonIndexSignatures: () => SignatureReflection[];

method getProperties

getProperties: () => DeclarationReflection[];

method hasGetterOrSetter

hasGetterOrSetter: () => boolean;

method isDeclaration

isDeclaration: () => this is DeclarationReflection;

method toObject

toObject: (serializer: Serializer) => JSONOutput.DeclarationReflection;

method toString

toString: () => string;

Return a string representation of this reflection.

method traverse

traverse: (callback: TraverseCallback) => void;

class DefaultTheme

class DefaultTheme extends Theme {}

constructor

constructor(renderer: Renderer);

Create a new DefaultTheme instance.
Parameter renderer
The renderer this theme is attached to.

property ContextClass

ContextClass: typeof DefaultThemeRenderContext;

property darkTheme

darkTheme: any;

property defaultLayoutTemplate

defaultLayoutTemplate: (
    pageEvent: PageEvent<Reflection>,
    template: RenderTemplate<PageEvent<Reflection>>
) => JSX.Element;

property documentTemplate

documentTemplate: (pageEvent: PageEvent<DocumentReflection>) => JSX.Element;

property hierarchyTemplate

hierarchyTemplate: (pageEvent: PageEvent<ProjectReflection>) => JSX.Element;

property highlightLanguages

highlightLanguages: any;

property icons

icons: Icons;

The icons which will actually be rendered. The source of truth lives on the theme, and the DefaultThemeRenderContext.icons member will produce references to these.
These icons will be written twice. Once to an icons.svg file in the assets directory which will be referenced by icons on the context, and once to an icons.js file so that references to the icons can be dynamically embedded within the page for use by the search dropdown and when loading the page on file:// urls.
Custom themes may overwrite this entire object or individual properties on it to customize the icons used within the page, however TypeDoc currently assumes that all icons are svg elements, so custom themes must also use svg elements.

property ignoredHighlightLanguages

ignoredHighlightLanguages: any;

property indexTemplate

indexTemplate: (pageEvent: PageEvent<ProjectReflection>) => JSX.Element;

property lightTheme

lightTheme: any;

property reflectionTemplate

reflectionTemplate: (pageEvent: PageEvent<ContainerReflection>) => JSX.Element;

property router

router: Router;

property usedFileNames

usedFileNames: Set<string>;

method buildNavigation

buildNavigation: (project: ProjectReflection) => NavigationElement[];

method getNavigation

getNavigation: (project: ProjectReflection) => NavigationElement[];

If implementing a custom theme, it is recommended to override buildNavigation instead.

method getReflectionClasses

getReflectionClasses: (reflection: Reflection) => string;

method getReflectionIcon

getReflectionIcon: (
    reflection: Reflection
) => keyof this['icons'] & (string | number);

This is used so that themes may define multiple icons for modified icons (e.g. method, and inherited method)

method getRenderContext

getRenderContext: (
    pageEvent: PageEvent<Reflection>
) => DefaultThemeRenderContext;

method preRender

preRender: (_event: RendererEvent) => Promise<void>;

method render

render: (page: PageEvent) => string;

class DefaultThemeRenderContext

class DefaultThemeRenderContext {}

constructor

constructor(
    router: Router,
    theme: DefaultTheme,
    page: PageEvent<Reflection>,
    options: Options
);

property breadcrumbs

breadcrumbs: (props: Reflection) => JSX.Element;

property commentShortSummary

commentShortSummary: (props: Reflection) => JSX.Element | undefined;

property commentSummary

commentSummary: (props: Reflection) => JSX.Element | undefined;

property commentTags

commentTags: (props: Reflection) => JSX.Element | undefined;

property defaultLayout

defaultLayout: (
    template: import('./DefaultTheme.js').RenderTemplate<PageEvent<Reflection>>,
    props: PageEvent<Reflection>
) => JSX.Element;

property displayParts

displayParts: (
    parts: readonly CommentDisplayPart[] | undefined
) => JSX.Element | undefined;

Renders user comment markdown wrapped in a tsd-comment div

property documentTemplate

documentTemplate: (
    props: PageEvent<
        import('../../../models/DocumentReflection.js').DocumentReflection
    >
) => JSX.Element;

property footer

footer: () => JSX.Element;

property getAnchor

getAnchor: (reflection: Reflection) => string | undefined;

property getNavigation

getNavigation: () => import('./DefaultTheme.js').NavigationElement[];

property getReflectionClasses

getReflectionClasses: (refl: Reflection) => string;

property header

header: (props: PageEvent<Reflection>) => JSX.Element;

property hierarchy

hierarchy: (
    typeHierarchy:
        | import('../../../models/DeclarationReflection.js').DeclarationHierarchy
        | undefined
) => JSX.Element | undefined;

property hierarchyTemplate

hierarchyTemplate: (
    props: PageEvent<
        import('../../../models/ProjectReflection.js').ProjectReflection
    >
) => JSX.Element;

property hook

hook: EventHooks<RendererHooks, JSX.Element>;

property icons

readonly icons: Readonly<Icons>;

Icons available for use within the page. When getting an icon for a reflection, reflectionIcon should be used so that themes which define multiple icon variants can correctly specify which icon they want to be used.
Note: This creates a reference to icons declared by DefaultTheme.icons, to customize icons, that object must be modified instead.

property index

index: (
    props: import('../../../models/ContainerReflection.js').ContainerReflection
) => JSX.Element;

property indexTemplate

indexTemplate: (
    props: PageEvent<
        import('../../../models/ProjectReflection.js').ProjectReflection
    >
) => JSX.Element;

property markdown

markdown: (
    md: readonly CommentDisplayPart[] | NeverIfInternal<string | undefined>
) => string;

property member

member: (
    props:
        | import('../../../models/DocumentReflection.js').DocumentReflection
        | import('../../../models/DeclarationReflection.js').DeclarationReflection
) => JSX.Element;

property memberDeclaration

memberDeclaration: (
    props: import('../../../models/DeclarationReflection.js').DeclarationReflection
) => JSX.Element;

property memberGetterSetter

memberGetterSetter: (
    props: import('../../../models/DeclarationReflection.js').DeclarationReflection
) => JSX.Element;

property members

members: (
    props: import('../../../models/ContainerReflection.js').ContainerReflection
) => JSX.Element;

property memberSignatureBody

memberSignatureBody: (
    props: import('../../../models/SignatureReflection.js').SignatureReflection,
    r_1?: { hideSources?: boolean } | undefined
) => JSX.Element;

property memberSignatures

memberSignatures: (
    props: import('../../../models/DeclarationReflection.js').DeclarationReflection
) => JSX.Element;

property memberSignatureTitle

memberSignatureTitle: (
    props: import('../../../models/SignatureReflection.js').SignatureReflection,
    options?: { hideName?: boolean } | undefined
) => JSX.Element;

property memberSources

memberSources: (
    props:
        | import('../../../models/DeclarationReflection.js').DeclarationReflection
        | import('../../../models/SignatureReflection.js').SignatureReflection
) => JSX.Element;

property model

model: Reflection;

property moduleMemberSummary

moduleMemberSummary: (
    member:
        | import('../../../models/DocumentReflection.js').DocumentReflection
        | import('../../../models/DeclarationReflection.js').DeclarationReflection
) => JSX.Element;

property moduleReflection

moduleReflection: (
    mod:
        | import('../../../models/DeclarationReflection.js').DeclarationReflection
        | import('../../../models/ProjectReflection.js').ProjectReflection
) => JSX.Element;

navigation: (props: PageEvent<Reflection>) => JSX.Element;

property options

options: Options;

property page

page: PageEvent<Reflection>;

property pageNavigation

pageNavigation: (props: PageEvent<Reflection>) => JSX.Element;

property pageSidebar

pageSidebar: (props: PageEvent<Reflection>) => JSX.Element;

property reflectionFlags

reflectionFlags: (props: Reflection) => JSX.Element;

property reflectionIcon

reflectionIcon: (reflection: Reflection) => JSX.Element;

Do not override this method, override DefaultTheme.getReflectionIcon instead.

property reflectionPreview

reflectionPreview: (props: Reflection) => JSX.Element | undefined;

Rendered just after the description for a reflection. This can be used to render a shortened type display of a reflection that the rest of the page expands on.
Note: Will not be called for variables/type aliases, as they are summarized by their type declaration, which is already rendered by DefaultThemeRenderContext.memberDeclaration

property reflectionTemplate

reflectionTemplate: (
    props: PageEvent<
        import('../../../models/ContainerReflection.js').ContainerReflection
    >
) => JSX.Element;

property relativeURL

relativeURL: (url: string, cacheBust?: boolean) => string;

Avoid this in favor of urlTo if possible

property router

readonly router: Router;

property settings

settings: () => JSX.Element;

property sidebar

sidebar: (props: PageEvent<Reflection>) => JSX.Element;

property sidebarLinks

sidebarLinks: () => JSX.Element | null;

property slugger

readonly slugger: Slugger;

property theme

readonly theme: DefaultTheme;

toolbar: (props: PageEvent<Reflection>) => JSX.Element;

property type

type: (
    type: import('../../../models/types.js').SomeType | undefined,
    options?: { topLevelLinks: boolean } | undefined
) => JSX.Element;

property typeAndParent

typeAndParent: (props: import('../../../models/types.js').Type) => JSX.Element;

property typeDeclaration

typeDeclaration: (
    reflectionOwningType: Reflection,
    type: import('../../../models/types.js').SomeType
) => JSX.Children;

Wrapper around typeDetails which checks if it is useful and includes a "Type Declaration" header.

property typeDetails

typeDetails: (
    reflectionOwningType: Reflection,
    type: import('../../../models/types.js').SomeType,
    renderAnchors: boolean
) => JSX.Children;

Used to render additional details about a type. This is used to implement the @expand tag, comments on union members, comments on object type members...

property typeDetailsIfUseful

typeDetailsIfUseful: (
    reflectionOwningType: Reflection,
    type: import('../../../models/types.js').SomeType | undefined
) => JSX.Children;

Should call the typeDetails helper if rendering additional details about the type will provide the user with more information about the type.

property typeParameters

typeParameters: (
    typeParameters: import('../../../models/TypeParameterReflection.js').TypeParameterReflection[]
) => JSX.Element;

property urlTo

urlTo: (reflection: Reflection) => string | undefined;

class Deserializer

class Deserializer {}

Deserializes TypeDoc's JSON output back to Reflection instances.
None Deserializes TypeDoc's JSON output

constructor

constructor(logger: Logger);

property logger

logger: Logger;

property oldFileIdToNewFileId

oldFileIdToNewFileId: Record<FileId, any>;

property oldIdToNewId

oldIdToNewId: Record<ReflectionId, any>;

property project

project: any;

property projectRoot

projectRoot: NormalizedPath;

Only set when deserializing.

property reflectionBuilders

reflectionBuilders: {
    [x: string]: (parent: any, obj: JSONOutput.SomeType[]) => ReflectionVariant;
};

property typeBuilders

typeBuilders: {
    [x: string]: (obj: JSONOutput.SomeType[], de: Deserializer) => TypeKindMap;
};

method addDeserializer

addDeserializer: (de: DeserializerComponent) => void;

method constructReflection

constructReflection: <T extends JSONOutput.SomeReflection>(
    obj: T
) => ReflectionVariant;

method constructType

constructType: <T extends JSONOutput.SomeType>(obj: T) => TypeKindMap;

method defer

defer: (cb: (project: ProjectReflection) => void) => void;

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.

method fromObject

fromObject: <T>(
    receiver: { fromObject(d: Deserializer, o: T): void },
    obj: T
) => void;

method revive

revive: {
    <T extends object, U extends Deserializable<T>>(
        source: NonNullable<T>,
        creator: (obj: T) => U
    ): U;
    <T extends object, U extends Deserializable<T>>(
        source: T,
        creator: (obj: T) => U
    ): U;
};

method reviveMany

reviveMany: {
    <T, U extends Deserializable<T>>(
        sourceArray: T[],
        creator: (obj: T) => U
    ): U[];
    <T, U extends Deserializable<T>>(
        sourceArray: T[],
        creator: (obj: T) => U
    ): U[];
};

method reviveProject

reviveProject: (
    name: string,
    projectObj: JSONOutput.ProjectReflection,
    options: { projectRoot: NormalizedPath; registry: FileRegistry }
) => ProjectReflection;

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.

method reviveProjects

reviveProjects: (
    name: string,
    projects: readonly JSONOutput.ProjectReflection[],
    options: {
        projectRoot: NormalizedPath;
        registry: FileRegistry;
        alwaysCreateEntryPointModule: boolean;
    }
) => ProjectReflection;

method reviveType

reviveType: {
    <T extends JSONOutput.SomeType>(obj: T): TypeKindMap;
    <T extends JSONOutput.SomeType>(obj: T): any;
};

class DocumentReflection

class DocumentReflection extends Reflection {}

Non-TS reflection type which is used to represent markdown documents included in the docs.

constructor

constructor(
    name: string,
    parent: Reflection,
    content: CommentDisplayPart[],
    frontmatter: Record<string, unknown>
);

property children

children?: DocumentReflection[];

Child documents, if any are present.

property content

content: CommentDisplayPart[];

The content to be displayed on the page for this reflection.

property frontmatter

frontmatter: Record<string, unknown>;

Frontmatter included in document

property relevanceBoost

relevanceBoost?: number;

A precomputed boost derived from the searchCategoryBoosts and searchGroupBoosts options, used when boosting search relevance scores at runtime. May be modified by plugins.

property variant

readonly variant: string;

method addChild

addChild: (child: DocumentReflection) => void;

method fromObject

fromObject: (de: Deserializer, obj: JSONOutput.DocumentReflection) => void;

method isDocument

isDocument: () => this is DocumentReflection;

method toObject

toObject: (serializer: Serializer) => JSONOutput.DocumentReflection;

method traverse

traverse: (callback: TraverseCallback) => void;

class FancyConsoleLogger

class FancyConsoleLogger extends ConsoleLogger {}

A logger that outputs all messages to the console.

method addContext

protected addContext: (
    message: string,
    level: Exclude<LogLevel, LogLevel.None>,
    ...args: [MinimalNode?] | [number, MinimalSourceFile]
) => string;

class FileRegistry

class FileRegistry {}

property mediaToPath

protected mediaToPath: Map<FileId, NormalizedPath>;

property mediaToReflection

protected mediaToReflection: Map<FileId, ReflectionId>;

property names

protected names: Map<FileId, string>;

property nameUsage

protected nameUsage: Map<string, number>;

property nextId

protected nextId: number;

property pathToMedia

protected pathToMedia: Map<NormalizedPath, FileId>;

property reflectionToPath

protected reflectionToPath: Map<ReflectionId, NormalizedPath>;

method fromObject

fromObject: (de: Deserializer, obj: JSONOutput.FileRegistry) => void;

Revive a file registry from disc. Note that in the packages context this may be called multiple times on a single object, and should merge in files from the other registries.

method getName

getName: (id: FileId) => string | undefined;

method getNameToAbsoluteMap

getNameToAbsoluteMap: () => ReadonlyMap<string, string>;

method getReflectionPath

getReflectionPath: (reflection: Reflection) => string | undefined;

method register

register: (
    sourcePath: NormalizedPath,
    relativePath: NormalizedPath
) => { target: FileId; anchor: string | undefined } | undefined;

method registerAbsolute

registerAbsolute: (absolute: NormalizedPath) => {
    target: FileId;
    anchor: string | undefined;
};

method registerReflection

registerReflection: (absolute: NormalizedPath, reflection: Reflection) => void;

Registers the specified path as the canonical file for this reflection

method registerReflectionPath

registerReflectionPath: (
    absolute: NormalizedPath,
    reflection: Reflection
) => void;

Registers the specified path as a path which should be resolved to the specified reflection. A reflection *may* be associated with multiple paths.

method removeReflection

removeReflection: (reflection: Reflection) => void;

method resolve

resolve: (
    id: FileId,
    project: ProjectReflection
) => string | Reflection | undefined;

method resolvePath

resolvePath: (id: FileId) => string | undefined;

method toObject

toObject: (ser: Serializer) => JSONOutput.FileRegistry;

class GroupRouter

class GroupRouter extends BaseRouter {}

Router which places reflections in folders according to @group tags. Routers

property groupReferencesByType

groupReferencesByType: any;

method getIdealBaseName

protected getIdealBaseName: (reflection: Reflection) => string;

class IndexedAccessType

class IndexedAccessType extends Type {}

Represents an indexed access type. Types

constructor

constructor(objectType: SomeType, indexType: SomeType);

property indexType

indexType: SomeType;

property objectType

objectType: SomeType;

property type

readonly type: string;

method getTypeString

protected getTypeString: () => string;

method needsParenthesis

needsParenthesis: () => boolean;

method toObject

toObject: (serializer: Serializer) => JSONOutput.IndexedAccessType;

class IndexEvent

class IndexEvent {}

An event emitted when the search index is being prepared.

constructor

constructor(searchResults: (DeclarationReflection | DocumentReflection)[]);

property PREPARE_INDEX

static readonly PREPARE_INDEX: string;

Triggered on the renderer when the search index is being prepared.

property searchFields

searchFields: Record<string, string>[];

Additional search fields to be used when creating the search index. name, comment and document may be specified to overwrite TypeDoc's search fields.
Do not use id as a custom search field.

property searchFieldWeights

readonly searchFieldWeights: Record<string, number>;

Weights for the fields defined in searchFields. The default will weight name as 10x more important than comment and document content.
If a field added to searchFields is not added to this object, it will **not** be searchable.
Do not replace this object, instead, set new properties on it for custom search fields added by your plugin.

property searchResults

searchResults: (DeclarationReflection | DocumentReflection)[];

May be filtered by plugins to reduce the results available. Additional items *should not* be added to this array.
If you remove an index from this array, you must also remove the same index from searchFields. The removeResult helper will do this for you.

method removeResult

removeResult: (index: number) => void;

Remove a search result by index.

class InferredType

class InferredType extends Type {}

Represents an inferred type, U in the example below.

type Z = Promise<string> extends Promise<infer U> : never

Types

constructor

constructor(name: string, constraint?: SomeType);

property constraint

constraint?: SomeType;

property name

name: string;

property type

readonly type: string;

method getTypeString

protected getTypeString: () => string;

method needsParenthesis

needsParenthesis: (context: TypeContext) => boolean;

method toObject

toObject: (serializer: Serializer) => JSONOutput.InferredType;

class IntersectionType

class IntersectionType extends Type {}

Represents an intersection type.
let value: A & B;
Types

constructor

constructor(types: SomeType[]);

property type

readonly type: string;

property types

types: SomeType[];

method getTypeString

protected getTypeString: () => string;

method needsParenthesis

needsParenthesis: (context: TypeContext) => boolean;

method toObject

toObject: (serializer: Serializer) => JSONOutput.IntersectionType;

class IntrinsicType

class IntrinsicType extends Type {}

Represents an intrinsic type like string or boolean.
let value: number;
Types

constructor

constructor(name: string);

property name

name: string;

property type

readonly type: string;

method getTypeString

protected getTypeString: () => string;

method needsParenthesis

needsParenthesis: () => boolean;

method toObject

toObject: () => JSONOutput.IntrinsicType;

class KindDirRouter

class KindDirRouter extends KindRouter {}

Router which places reflections in folders according to their kind, but creates each page as /index.html to allow for clean URLs. Routers

method buildChildPages

protected buildChildPages: (
    reflection: Reflection,
    outPages: PageDefinition[]
) => void;

method getFullUrl

getFullUrl: (refl: Reflection) => string;

method relativeUrl

relativeUrl: (from: Reflection, to: Reflection) => string;

class KindRouter

class KindRouter extends BaseRouter {}

Router which places reflections in folders according to their kind. Routers

property directories

directories: Map<ReflectionKind, string>;

method getIdealBaseName

protected getIdealBaseName: (reflection: Reflection) => string;

class LiteralType

class LiteralType extends Type {}

Represents a literal type.
type A = "A" type B = 1
Types

constructor

constructor(value: string | number | bigint | boolean);

property type

readonly type: string;

property value

value: string | number | bigint | boolean;

method getTypeString

protected getTypeString: () => string;

Return a string representation of this type.

method needsParenthesis

needsParenthesis: () => boolean;

method toObject

toObject: () => JSONOutput.LiteralType;

class MappedType

class MappedType extends Type {}

Represents a mapped type.

{ -readonly [K in Parameter as Name]?: Template }

Types

constructor

constructor(
    parameter: string,
    parameterType: SomeType,
    templateType: SomeType,
    readonlyModifier?: '+' | '-',
    optionalModifier?: '+' | '-',
    nameType?: SomeType
);

property nameType

nameType?: SomeType;

property optionalModifier

optionalModifier?: '+' | '-';

property parameter

parameter: string;

property parameterType

parameterType: SomeType;

property readonlyModifier

readonlyModifier?: '+' | '-';

property templateType

templateType: SomeType;

property type

readonly type: string;

method getTypeString

protected getTypeString: () => string;

method needsParenthesis

needsParenthesis: () => boolean;

method toObject

toObject: (serializer: Serializer) => JSONOutput.MappedType;

class MarkdownEvent

class MarkdownEvent {}

An event emitted when markdown is being parsed. Allows other plugins to manipulate the result.
See Also
- MarkdownEvent.PARSE

constructor

constructor(
    page: PageEvent<RouterTarget>,
    originalText: string,
    parsedText: string
);

property originalText

readonly originalText: string;

The unparsed original text.

property page

readonly page: PageEvent<RouterTarget>;

The page that this markdown is being parsed for.

property PARSE

static readonly PARSE: string;

Triggered on the renderer when this plugin parses a markdown string.

property parsedText

parsedText: string;

The parsed output.

class NamedTupleMember

class NamedTupleMember extends Type {}

Represents a named member of a tuple type.
let value: [name: string];
Types

constructor

constructor(name: string, isOptional: boolean, element: SomeType);

property element

element: SomeType;

property isOptional

isOptional: boolean;

property name

name: string;

property type

readonly type: string;

method getTypeString

protected getTypeString: () => string;

Return a string representation of this type.

method needsParenthesis

needsParenthesis: () => boolean;

method toObject

toObject: (serializer: Serializer) => JSONOutput.NamedTupleMemberType;

class OptionalType

class OptionalType extends Type {}

Represents an optional type
type Z = [1, 2?] // ^^
Types

constructor

constructor(elementType: SomeType);

property elementType

elementType: SomeType;

property type

readonly type: string;

method getTypeString

protected getTypeString: () => string;

method needsParenthesis

needsParenthesis: () => boolean;

method toObject

toObject: (serializer: Serializer) => JSONOutput.OptionalType;

class Options

class Options {}

Maintains a collection of option declarations split into TypeDoc options and TypeScript options. Ensures options are of the correct type for calling code.
### Option Discovery
Since plugins commonly add custom options, and TypeDoc does not permit options which have not been declared to be set, options must be read twice. The first time options are read, a noop logger is passed so that any errors are ignored. Then, after loading plugins, options are read again, this time with the logger specified by the application.
Options are read in a specific order. 1. argv (0) - Must be read first since it should change the files read when passing --options or --tsconfig. 2. typedoc-json (100) - Read next so that it can specify the tsconfig.json file to read. 3. tsconfig-json (200) - Last config file reader, cannot specify the typedoc.json file to read. 4. argv (300) - Read argv again since any options set there should override those set in config files.
None Contains all of TypeDoc's option declarations & values

constructor

constructor();

property packageDir

packageDir?: string;

In packages mode, the directory of the package being converted.

method addDeclaration

addDeclaration: {
    <K extends keyof TypeDocOptionMap>(
        declaration: { name: K } & KeyToDeclaration<K>
    ): void;
    (declaration: NeverIfInternal<Readonly<DeclarationOption>>): void;
};

Adds an option declaration to the container with extra type checking to ensure that the runtime type is consistent with the declared type.
Parameter declaration
The option declaration that should be added.
Adds an option declaration to the container.
Parameter declaration
The option declaration that should be added.

method addReader

addReader: (reader: OptionsReader) => void;

Adds an option reader that will be used to read configuration values from the command line, configuration files, or other locations.
Parameter reader

method copyForPackage

copyForPackage: (packageDir: string) => Options;

Clones the options, intended for use in packages mode.

method getCompilerOptions

getCompilerOptions: (logger: Logger) => ts.CompilerOptions;

Gets the set compiler options.

method getDeclaration

getDeclaration: (name: string) => Readonly<DeclarationOption> | undefined;

Gets a declaration by one of its names.
Parameter name

method getDeclarations

getDeclarations: () => Readonly<DeclarationOption>[];

Gets all declared options.

method getFileNames

getFileNames: () => readonly string[];

Gets the file names discovered through reading a tsconfig file.

method getHelp

getHelp: () => string;

Get the help message to be displayed to the user if --help is passed.

method getProjectReferences

getProjectReferences: () => readonly ts.ProjectReference[];

Gets the project references - used in solution style tsconfig setups.

method getRawValues

getRawValues: () => Readonly<Partial<TypeDocOptionValues>>;

Gets all of the TypeDoc option values defined in this option container.

method getSimilarOptions

getSimilarOptions: (missingName: string) => string[];

Discover similar option names to the given name, for use in error reporting.

method getValue

getValue: {
    <K extends keyof TypeDocOptionMap>(name: K): TypeDocOptionValues[K];
    (name: NeverIfInternal<string>): unknown;
};

Gets a value for the given option key, throwing if the option has not been declared.
Parameter name

method isSet

isSet: {
    (name: keyof TypeDocOptions): boolean;
    (name: NeverIfInternal<string>): boolean;
};

Checks if the given option's value is deeply strict equal to the default.
Parameter name

method read

read: (
    logger: Logger,
    cwd?: string,
    usedFile?: (path: string) => void
) => Promise<void>;

method reset

reset: {
    (name?: keyof TypeDocOptions): void;
    (name?: NeverIfInternal<string>): void;
};

Resets the option bag to all default values. If a name is provided, will only reset that name.

method setCompilerOptions

setCompilerOptions: (
    fileNames: readonly string[],
    options: ts.CompilerOptions,
    projectReferences: readonly ts.ProjectReference[] | undefined
) => void;

Sets the compiler options that will be used to get a TS program.

method setValue

setValue: {
    <K extends keyof TypeDocOptionMap>(
        name: K,
        value: Exclude<TypeDocOptions[K], undefined>,
        configPath?: string
    ): void;
    (
        name: NeverIfInternal<string>,
        value: NeverIfInternal<unknown>,
        configPath?: NeverIfInternal<string>
    ): void;
};

Sets the given declared option. Throws if setting the option fails.
Parameter name
Parameter value
Parameter configPath
the directory to resolve Path type values against

class Outputs

class Outputs {}

constructor

constructor(application: Application);

property application

readonly application: Application;

method addOutput

addOutput: (
    name: string,
    output: (path: string, project: ProjectReflection) => Promise<void>
) => void;

method getOutputSpecs

getOutputSpecs: () => OutputSpecification[];

method setDefaultOutputName

setDefaultOutputName: (name: string) => void;

method writeOutput

writeOutput: (
    output: OutputSpecification,
    project: ProjectReflection
) => Promise<void>;

method writeOutputs

writeOutputs: (project: ProjectReflection) => Promise<void>;

class PackageJsonReader

class PackageJsonReader implements OptionsReader {}

property name

name: string;

property order

order: number;

property supportsPackages

supportsPackages: boolean;

method read

read: (
    container: Options,
    logger: Logger,
    cwd: string,
    usedFile: (path: string) => void
) => void;

class PageEvent

class PageEvent<out Model extends RouterTarget = RouterTarget> {}

An event emitted by the Renderer class before and after the markup of a page is rendered.
See Also
- Renderer.EVENT_BEGIN_PAGE
- Renderer.EVENT_END_PAGE

constructor

constructor(model: RouterTarget);

property BEGIN

static readonly BEGIN: string;

Triggered before a document will be rendered.

property contents

contents?: string;

The final html content of this page.
Should be rendered by layout templates and can be modified by plugins.

property END

static readonly END: string;

Triggered after a document has been rendered, just before it is written to disc.

property filename

filename: string;

The filename the page will be written to.

property model

readonly model: RouterTarget;

The model that should be rendered on this page.

property pageHeadings

pageHeadings: PageHeading[];

Links to content within this page that should be rendered in the page navigation. This is built when rendering the document content.

property pageKind

pageKind: PageKind;

The type of page this is.

property pageSections

pageSections: { title: string; headings: PageHeading[] }[];

Sections of the page, generally set by @groups

property project

project: ProjectReflection;

The project the renderer is currently processing.

property url

url: string;

The url this page will be located at.

method isReflectionEvent

isReflectionEvent: () => this is PageEvent<Reflection>;

method startNewSection

startNewSection: (title: string) => void;

Start a new section of the page. Sections are collapsible within the "On This Page" sidebar.

class ParameterReflection

class ParameterReflection extends Reflection {}

Reflections

property defaultValue

defaultValue?: string;

property parent

parent?: SignatureReflection;

property type

type?: SomeType;

property variant

readonly variant: string;

method fromObject

fromObject: (de: Deserializer, obj: JSONOutput.ParameterReflection) => void;

method isParameter

isParameter: () => this is ParameterReflection;

method toObject

toObject: (serializer: Serializer) => JSONOutput.ParameterReflection;

method toString

toString: () => string;

Return a string representation of this reflection.

method traverse

traverse: (callback: TraverseCallback) => void;

class PredicateType

class PredicateType extends Type {}

Represents a type predicate.

function isString(x: unknown): x is string {}
function assert(condition: boolean): asserts condition {}

Types

constructor

constructor(name: string, asserts: boolean, targetType?: SomeType);

Create a new PredicateType instance.
Parameter name
The identifier name which is tested by the predicate.
Parameter asserts
True if the type is of the form asserts val is string, false if the type is of the form val is string
Parameter targetType
The type that the identifier is tested to be. May be undefined if the type is of the form asserts val. Will be defined if the type is of the form asserts val is string or val is string.

property asserts

asserts: boolean;

property name

name: string;

property targetType

targetType?: SomeType;

property type

readonly type: string;

method getTypeString

protected getTypeString: () => string;

Return a string representation of this type.

method needsParenthesis

needsParenthesis: () => boolean;

method toObject

toObject: (serializer: Serializer) => JSONOutput.PredicateType;

class ProjectReflection

class ProjectReflection extends ContainerReflection {}

A reflection that represents the root of the project.
The project reflection acts as a global index, one may receive all reflections and source files of the processed project through this reflection. Reflections

constructor

constructor(name: string, registry: FileRegistry);

property files

readonly files: FileRegistry;

Object which describes where to find content for relative links.

property packageName

packageName?: string;

The name of the package that this reflection documents according to package.json.

property packageVersion

packageVersion?: string;

The version of the package that this reflection documents according to package.json.

property readme

readme?: CommentDisplayPart[];

The contents of the readme.md file of the project when found.

property reflections

reflections: { [id: number]: Reflection };

A list of all reflections within the project. DO NOT MUTATE THIS OBJECT. All mutation should be done via registerReflection and removeReflection to ensure that links to reflections remain valid.
This may be replaced with a Map<number, Reflection> someday.

property variant

readonly variant: string;

method fromObject

fromObject: (de: Deserializer, obj: JSONOutput.ProjectReflection) => void;

method getReflectionById

getReflectionById: (id: number) => Reflection | undefined;

Gets the reflection registered for the given reflection ID, or undefined if it is not present in the project.

method getReflectionsByKind

getReflectionsByKind: (kind: ReflectionKind) => Reflection[];

Return a list of all reflections in this project of a certain kind.
Parameter kind
The desired kind of reflection.
Returns
An array containing all reflections with the desired kind.

method isProject

isProject: () => this is ProjectReflection;

Return whether this reflection is the root / project reflection.

method registerReflection

registerReflection: (
    reflection: Reflection,
    id: ReflectionSymbolId | undefined,
    filePath: NormalizedPath | undefined
) => void;

Registers the given reflection so that it can be quickly looked up by helper methods. Should be called for *every* reflection added to the project.
Note: During conversion, Context.registerReflection should be used instead so that symbols can be saved for later use.

method removeReflection

removeReflection: (reflection: Reflection) => void;

Removes a reflection from the documentation. Can be used by plugins to filter reflections out of the generated documentation. Has no effect if the reflection is not present in the project.

method removeTypeReflections

removeTypeReflections: (type: Type | undefined) => void;

Removes references to reflections contained within the provided type. Plugins which overwrite types on reflections should pass the type to this method before overwriting the property. 0.26.6

method symbolIdHasBeenRemoved

symbolIdHasBeenRemoved: (id: ReflectionSymbolId) => boolean;

method toObject

toObject: (serializer: Serializer) => JSONOutput.ProjectReflection;

class QueryType

class QueryType extends Type {}

Represents a type that is constructed by querying the type of a reflection.
const x = 1 type Z = typeof x // query on reflection for x
Types

constructor

constructor(queryType: ReferenceType);

property queryType

queryType: ReferenceType;

property type

readonly type: string;

method getTypeString

protected getTypeString: () => string;

method needsParenthesis

needsParenthesis: () => boolean;

method toObject

toObject: (serializer: Serializer) => JSONOutput.QueryType;

class ReferenceReflection

class ReferenceReflection extends DeclarationReflection {}

Describes a reflection which does not exist at this location, but is referenced. Used for imported reflections.

// a.ts
export const a = 1;
// b.ts
import { a } from './a';
// Here to avoid extra work we create a reference to the original reflection in module a instead
// of copying the reflection.
export { a };

Reflections

property variant

readonly variant: string;

method fromObject

fromObject: (de: Deserializer, obj: JSONOutput.ReferenceReflection) => void;

method getChildByName

getChildByName: (arg: string | string[]) => Reflection | undefined;

method getTargetReflection

getTargetReflection: () => Reflection;

Gets the reflection that is referenced. This may be another reference reflection. To fully resolve any references, use getTargetReflectionDeep.

method getTargetReflectionDeep

getTargetReflectionDeep: () => Reflection;

Gets the reflection that is referenced, this will fully resolve references. To only resolve one reference, use getTargetReflection.

method toObject

toObject: (serializer: Serializer) => JSONOutput.ReferenceReflection;

method tryGetTargetReflection

tryGetTargetReflection: () => Reflection | undefined;

Tries to get the reflection that is referenced. This may be another reference reflection. To fully resolve any references, use tryGetTargetReflectionDeep.

method tryGetTargetReflectionDeep

tryGetTargetReflectionDeep: () => Reflection | undefined;

Tries to get the reflection that is referenced, this will fully resolve references. To only resolve one reference, use tryGetTargetReflection.

class ReferenceType

class ReferenceType extends Type {}

Represents a type that refers to another reflection like a class, interface or enum.
let value: MyClass<T>;
Types

property externalUrl

externalUrl?: string;

If this reference type refers to a reflection defined by a project not being rendered, points to the url that this type should be linked to.

property highlightedProperties

highlightedProperties?: Map<string, CommentDisplayPart[]>;

Sometimes a few properties are more important than the rest of the properties within a type. This occurs most often with object parameters, where users want to specify @param foo.bar to highlight something about the bar property.
Does NOT support nested properties.

property name

name: string;

The name of the referenced type.
If the symbol cannot be found because it's not part of the documentation this can be used to represent the type.

property package

package?: string;

The package that this type is referencing.

property preferValues

preferValues: boolean;

If set, will prefer reflections with ReflectionKinds which represent values rather than those which represent types.

property qualifiedName

qualifiedName: string;

The fully qualified name of the referenced type, relative to the file it is defined in. This will usually be the same as name, unless namespaces are used.

property refersToTypeParameter

refersToTypeParameter: boolean;

If set, no warnings about something not being exported should be created since this may be referring to a type created with infer X which will not be registered on the project.

property reflection

readonly reflection: Reflection;

The resolved reflection.

property symbolId

readonly symbolId: ReflectionSymbolId;

If not resolved, the symbol id of the reflection, otherwise undefined.

property type

readonly type: string;

property typeArguments

typeArguments?: SomeType[];

The type arguments of this reference.

method createResolvedReference

static createResolvedReference: (
    name: string,
    target: Reflection | ReflectionId,
    project: ProjectReflection | null
) => ReferenceType;

method createUnresolvedReference

static createUnresolvedReference: (
    name: string,
    target: ReflectionSymbolId,
    project: ProjectReflection,
    qualifiedName: string
) => ReferenceType;

method fromObject

fromObject: (de: Deserializer, obj: JSONOutput.ReferenceType) => void;

method getTypeString

protected getTypeString: () => string;

method isIntentionallyBroken

isIntentionallyBroken: () => boolean;

Checks if this type is a reference type because it uses a name, but is intentionally not pointing to a reflection. This happens for type parameters and when representing a mapped type.

method needsParenthesis

needsParenthesis: () => boolean;

method toDeclarationReference

toDeclarationReference: () => DeclarationReference;

Convert this reference type to a declaration reference used for resolution of external types.

method toObject

toObject: (serializer: Serializer) => JSONOutput.ReferenceType;

class Reflection

abstract class Reflection {}

Base class for all reflection classes.
While generating a documentation, TypeDoc generates an instance of ProjectReflection as the root for all reflections within the project. All other reflections are represented by the DeclarationReflection class.
This base class exposes the basic properties one may use to traverse the reflection tree. You can use the ContainerReflection.children and parent properties to walk the tree. The ContainerReflection.groups property contains a list of all children grouped and sorted for rendering. Reflections

constructor

constructor(name: string, kind: ReflectionKind, parent?: Reflection);

property comment

comment?: Comment;

The parsed documentation comment attached to this reflection.

property flags

flags: ReflectionFlags;

property id

id: Number & { __reflectionIdBrand: never };

Unique id of this reflection.

property kind

kind: ReflectionKind;

The kind of this reflection.

property name

name: string;

The symbol name of this reflection.

property parent

parent?: Reflection;

The reflection this reflection is a child of.

property project

project: ProjectReflection;

property variant

abstract readonly variant: keyof ReflectionVariant;

Discriminator representing the type of reflection represented by this object.

method fromObject

fromObject: (de: Deserializer, obj: JSONOutput.Reflection) => void;

method getChildByName

getChildByName: (arg: string | string[]) => Reflection | undefined;

Return a child by its name.
Parameter arg
The name hierarchy of the child to look for.
Returns
The found child or undefined.

method getFriendlyFullName

getFriendlyFullName: () => string;

Return the full name of this reflection, with signature names dropped if possible without introducing ambiguity in the name.

method getFullName

getFullName: (separator?: string) => string;

Return the full name of this reflection. Intended for use in debugging. For log messages intended to be displayed to the user for them to fix, prefer getFriendlyFullName instead.
The full name contains the name of this reflection and the names of all parent reflections.
Parameter separator
Separator used to join the names of the reflections.
Returns
The full name of this reflection.

method hasComment

hasComment: (notRenderedTags?: readonly TagString[]) => boolean;

Checks if this reflection has a comment which contains any visible text.
Returns
TRUE when this reflection has a visible comment.

method hasGetterOrSetter

hasGetterOrSetter: () => boolean;

method isContainer

isContainer: () => this is ContainerReflection;

method isDeclaration

isDeclaration: () => this is DeclarationReflection;

method isDeprecated

isDeprecated: () => boolean;

Check if this reflection or any of its parents have been marked with the @deprecated tag.

method isDocument

isDocument: () => this is DocumentReflection;

method isParameter

isParameter: () => this is ParameterReflection;

method isProject

isProject: () => this is ProjectReflection;

Return whether this reflection is the root / project reflection.

method isReference

isReference: () => this is ReferenceReflection;

method isSignature

isSignature: () => this is SignatureReflection;

method isTypeParameter

isTypeParameter: () => this is TypeParameterReflection;

method kindOf

kindOf: (kind: ReflectionKind | ReflectionKind[]) => boolean;

Test whether this reflection is of the given kind.

method setFlag

setFlag: (flag: ReflectionFlag, value?: boolean) => void;

Set a flag on this reflection.

method toObject

toObject: (serializer: Serializer) => JSONOutput.Reflection;

method toString

toString: () => string;

Return a string representation of this reflection.

method toStringHierarchy

toStringHierarchy: (indent?: string) => string;

Return a string representation of this reflection and all of its children.
Note: This is intended as a debug tool only, output may change between patch versions.
Parameter indent
Used internally to indent child reflections.

method traverse

abstract traverse: (callback: TraverseCallback) => void;

Traverse most potential child reflections of this reflection.
Note: This may not necessarily traverse child reflections contained within the type property of the reflection, and should not be relied on for this. Support for checking object types will likely be removed in v0.29.
The given callback will be invoked for all children, signatures and type parameters attached to this reflection.
Parameter callback
The callback function that should be applied for each child reflection.

method visit

visit: (visitor: ReflectionVisitor) => void;

class ReflectionCategory

class ReflectionCategory {}

A category of reflections.
Reflection categories are created by the ´CategoryPlugin´ in the resolving phase of the dispatcher. The main purpose of categories is to be able to more easily render human readable children lists in templates.

constructor

constructor(title: string);

Create a new ReflectionCategory instance.
Parameter title
The title of this category.

property children

children: (DeclarationReflection | DocumentReflection)[];

All reflections of this category.

property description

description?: CommentDisplayPart[];

The user specified description, if any, set with @categoryDescription

property title

title: string;

The title, a string representation of this category.

method fromObject

fromObject: (de: Deserializer, obj: JSONOutput.ReflectionCategory) => void;

method toObject

toObject: () => JSONOutput.ReflectionCategory;

class ReflectionFlags

class ReflectionFlags {}

This must extend Array in order to work with Handlebar's each helper.

property isAbstract

readonly isAbstract: boolean;

property isConst

readonly isConst: boolean;

property isExternal

readonly isExternal: boolean;

Is this a declaration from an external document?

property isInherited

readonly isInherited: boolean;

property isOptional

readonly isOptional: boolean;

Whether this reflection is an optional component or not.
Applies to function parameters and object members.

property isPrivate

readonly isPrivate: boolean;

Is this a private member?

property isProtected

readonly isProtected: boolean;

Is this a protected member?

property isPublic

readonly isPublic: boolean;

Is this a public member?

property isReadonly

readonly isReadonly: boolean;

property isRest

readonly isRest: boolean;

Whether it's a rest parameter, like foo(...params);.

property isStatic

readonly isStatic: boolean;

Is this a static member?

method flagString

static flagString: (flag: ReflectionFlag) => TranslatedString;

method fromObject

fromObject: (obj: JSONOutput.ReflectionFlags) => void;

method getFlagStrings

getFlagStrings: () => TranslatedString[];

method hasFlag

hasFlag: (flag: ReflectionFlag) => boolean;

method setFlag

setFlag: (flag: ReflectionFlag, set: boolean) => void;

method toObject

toObject: () => JSONOutput.ReflectionFlags;

class ReflectionGroup

class ReflectionGroup {}

A group of reflections. All reflections in a group are of the same kind.
Reflection groups are created by the ´GroupHandler´ in the resolving phase of the dispatcher. The main purpose of groups is to be able to more easily render human readable children lists in templates.

constructor

constructor(title: string, owningReflection: Reflection);

Create a new ReflectionGroup instance.
Parameter title
The title of this group.
Parameter owningReflection
The reflection containing this group, useful for changing rendering based on a comment on a reflection.

property categories

categories?: ReflectionCategory[];

Categories contained within this group.

property children

children: (DeclarationReflection | DocumentReflection)[];

All reflections of this group.

property description

description?: CommentDisplayPart[];

User specified description via @groupDescription, if specified.

property owningReflection

readonly owningReflection: Reflection;

property title

title: string;

The title, a string representation of the typescript kind, of this group.

method fromObject

fromObject: (de: Deserializer, obj: JSONOutput.ReflectionGroup) => void;

method toObject

toObject: (serializer: Serializer) => JSONOutput.ReflectionGroup;

class ReflectionSymbolId

class ReflectionSymbolId {}

This exists so that TypeDoc can store a unique identifier for a ts.Symbol without keeping a reference to the ts.Symbol itself. This identifier should be stable across runs so long as the symbol is exported from the same file.

constructor

constructor(json: JSONOutput.ReflectionSymbolId);

property fileName

fileName?: NormalizedPath;

Note: This is **not** serialized, only packageName and packagePath path information is preserved when serializing. This is set so that it is available to plugins when initially converting a project.

property packageName

readonly packageName: string;

The name of the package which this symbol ID resides within.

property packagePath

readonly packagePath: NormalizedPath;

Path to the source file containing this symbol. Note that this is NOT an absolute path, but a package-relative path according to the directory containing package.json for the package name.

property pos

pos: number;

Note: This is **not** serialized. It exists for sorting by declaration order, but should not be needed when deserializing from JSON. Will be set to Infinity if the ID was deserialized from JSON.

property qualifiedName

readonly qualifiedName: string;

Qualified name of this symbol within the source file.

property transientId

transientId: number;

Note: This is **not** serialized. It exists to support detection of the differences between symbols which share declarations, but are instantiated with different type parameters. This will be NaN if the symbol reference is not transient. Note: This can only be non-NaN if pos is finite.

property UNKNOWN_PACKAGE

static readonly UNKNOWN_PACKAGE: string;

This will only be used if we somehow cannot find a package.json file for source code. This is very unlikely, but if it occurs then the packageName will be set to this string, and packagePath will have the absolute path to the source file.

method getStableKey

getStableKey: () => ReflectionSymbolIdString;

method toDeclarationReference

toDeclarationReference: () => DeclarationReference;

method toObject

toObject: () => JSONOutput.ReflectionSymbolId;

class ReflectionType

class ReflectionType extends Type {}

Represents a type which has it's own reflection like literal types. This type will likely go away at some point and be replaced by a dedicated ObjectType. Allowing reflections to be nested within types causes much pain in the rendering code.
let value: { a: string, b: number };
Types

constructor

constructor(declaration: DeclarationReflection);

property declaration

declaration: DeclarationReflection;

property type

readonly type: string;

method getTypeString

protected getTypeString: () => string;

method needsParenthesis

needsParenthesis: (where: TypeContext) => boolean;

method toObject

toObject: (serializer: Serializer) => JSONOutput.ReflectionType;

class Renderer

class Renderer extends AbstractComponent<Application, RendererEvents> {}

The renderer processes a ProjectReflection using a Theme instance and writes the emitted html documents to a output directory. You can specify which theme should be used using the --theme <name> command line argument.
Renderer is a subclass of EventDispatcher and triggers a series of events while a project is being processed. You can listen to these events to control the flow or manipulate the output.
* Renderer.EVENT_BEGIN Triggered before the renderer starts rendering a project. The listener receives an instance of RendererEvent.
* Renderer.EVENT_BEGIN_PAGE Triggered before a document will be rendered. The listener receives an instance of PageEvent.
* Renderer.EVENT_END_PAGE Triggered after a document has been rendered, just before it is written to disc. The listener receives an instance of PageEvent.
* Renderer.EVENT_END Triggered after the renderer has written all documents. The listener receives an instance of RendererEvent.
* Renderer.EVENT_PREPARE_INDEX Triggered when the JavascriptIndexPlugin is preparing the search index. Listeners receive an instance of IndexEvent.
Writes HTML output from TypeDoc's models None

constructor

constructor(owner: Application);

property cacheBust

cacheBust: boolean;

property cleanOutputDir

cleanOutputDir: any;

property cname

cname: any;

property EVENT_BEGIN

static readonly EVENT_BEGIN: string;

property EVENT_BEGIN_PAGE

static readonly EVENT_BEGIN_PAGE: string;

property EVENT_END

static readonly EVENT_END: string;

property EVENT_END_PAGE

static readonly EVENT_END_PAGE: string;

property EVENT_PREPARE_INDEX

static readonly EVENT_PREPARE_INDEX: string;

property githubPages

githubPages: any;

property hooks

hooks: EventHooks<RendererHooks, JSX.Element>;

Hooks which will be called when rendering pages. Note: - Hooks added during output will be discarded at the end of rendering. - Hooks added during a page render will be discarded at the end of that page's render.
See RendererHooks for a description of each available hook, and when it will be called.

property markedPlugin

markedPlugin: MarkedPlugin;

property postRenderAsyncJobs

postRenderAsyncJobs: ((output: RendererEvent) => Promise<void>)[];

A list of async jobs which must be completed after rendering output files but before generation is considered successful. These functions will be called after all documents have been written to the filesystem.
This may be used by plugins to register work that must be done to finalize output files. For example: asynchronously generating an image referenced in a render hook.
Note: This array is cleared after calling the contained functions on each Renderer.render call.

property preRenderAsyncJobs

preRenderAsyncJobs: ((output: RendererEvent) => Promise<void>)[];

A list of async jobs which must be completed *before* rendering output. They will be called after RendererEvent.BEGIN has fired, but before any files have been written.
This may be used by plugins to register work that must be done to prepare output files. For example: asynchronously transform markdown to HTML.
Note: This array is cleared after calling the contained functions on each Renderer.render call.

property pretty

pretty: any;

property renderStartTime

renderStartTime: number;

property router

router?: Router;

The router which is used to determine the pages to render and how to link between pages.

property routerName

routerName: any;

property theme

theme?: Theme;

The theme that is used to render the documentation.

property themeName

themeName: any;

method defineRouter

defineRouter: (name: string, router: new (app: Application) => Router) => void;

Define a new router that can be used to determine the output structure.
Parameter name
Parameter router

method defineTheme

defineTheme: (name: string, theme: new (renderer: Renderer) => Theme) => void;

Define a new theme that can be used to render output. This API will likely be changing at some point, to allow more easily overriding parts of the theme without requiring additional boilerplate.
Parameter name
Parameter theme

method render

render: (project: ProjectReflection, outputDirectory: string) => Promise<void>;

Render the given project reflection to the specified output directory.
Parameter project
The project that should be rendered.
Parameter outputDirectory
The path of the directory the documentation should be rendered to.

class RendererEvent

class RendererEvent {}

An event emitted by the Renderer class at the very beginning and ending of the entire rendering process.
See Also
- Renderer.EVENT_BEGIN
- Renderer.EVENT_END

constructor

constructor(
    outputDirectory: string,
    project: ProjectReflection,
    pages: PageDefinition<RouterTarget>[]
);

property BEGIN

static readonly BEGIN: string;

Triggered before the renderer starts rendering a project.

property END

static readonly END: string;

Triggered after the renderer has written all documents.

property outputDirectory

readonly outputDirectory: string;

The path of the directory the documentation should be written to.

property pages

pages: PageDefinition<RouterTarget>[];

A list of all pages that will be generated.

property project

readonly project: ProjectReflection;

The project the renderer is currently processing.

class RestType

class RestType extends Type {}

Represents a rest type
type Z = [1, ...2[]] // ^^^^^^
Types

constructor

constructor(elementType: SomeType);

property elementType

elementType: SomeType;

property type

readonly type: string;

method getTypeString

protected getTypeString: () => string;

method needsParenthesis

needsParenthesis: () => boolean;

method toObject

toObject: (serializer: Serializer) => JSONOutput.RestType;

class SerializeEvent

class SerializeEvent {}

An event emitted by the Serializer class at the very beginning and ending of the a project serialization process.
See Also
- Serializer.EVENT_BEGIN
- Serializer.EVENT_END

constructor

constructor(project: ProjectReflection, output?: JSONProjectReflection);

property output

output: JSONProjectReflection;

property project

readonly project: ProjectReflection;

The project the renderer is currently processing.

class Serializer

class Serializer extends EventDispatcher<SerializerEvents> {}

Serializes TypeDoc's models to JSON
None Serializes TypeDoc's models to JSON

property EVENT_BEGIN

static readonly EVENT_BEGIN: string;

Triggered when the Serializer begins transforming a project.

property EVENT_END

static readonly EVENT_END: string;

Triggered when the Serializer has finished transforming a project.

property project

project: ProjectReflection;

Only set when serializing

property projectRoot

projectRoot: NormalizedPath;

Only set when serializing.

method addSerializer

addSerializer: <T extends object>(serializer: SerializerComponent<T>) => void;

method projectToObject

projectToObject: (
    value: ProjectReflection,
    projectRoot: NormalizedPath
) => ModelToObject<ProjectReflection>;

Same as toObject but emits Serializer.EVENT_BEGIN and Serializer.EVENT_END events.
Parameter value

method removeSerializer

removeSerializer: (serializer: SerializerComponent<any>) => void;

method toObject

toObject: {
    <T extends { toObject(serializer: Serializer): ModelToObject<T> }>(
        value: T
    ): ModelToObject<T>;
    <T extends { toObject(serializer: Serializer): ModelToObject<T> }>(
        value: T
    ): ModelToObject<T>;
};

method toObjectsOptional

toObjectsOptional: <
    T extends { toObject(serializer: Serializer): ModelToObject<T> }
>(
    value: T[] | undefined
) => ModelToObject<T>[] | undefined;

class SignatureReflection

class SignatureReflection extends Reflection {}

Reflections

constructor

constructor(
    name: string,
    kind:
        | ReflectionKind.CallSignature
        | ReflectionKind.IndexSignature
        | ReflectionKind.ConstructorSignature
        | ReflectionKind.GetSignature
        | ReflectionKind.SetSignature,
    parent: DeclarationReflection
);

property implementationOf

implementationOf?: ReferenceType;

A type that points to the reflection this reflection is the implementation of.
Applies to class members.

property inheritedFrom

inheritedFrom?: ReferenceType;

A type that points to the reflection this reflection has been inherited from.
Applies to interface and class members.

property kind

kind:
    | ReflectionKind.CallSignature
    | ReflectionKind.IndexSignature
    | ReflectionKind.ConstructorSignature
    | ReflectionKind.GetSignature
    | ReflectionKind.SetSignature;

property overwrites

overwrites?: ReferenceType;

A type that points to the reflection that has been overwritten by this reflection.
Applies to interface and class members.

property parameters

parameters?: ParameterReflection[];

property parent

parent: DeclarationReflection;

property sources

sources?: SourceReference[];

A list of all source files that contributed to this reflection.

property type

type?: SomeType;

property typeParameters

typeParameters?: TypeParameterReflection[];

property variant

readonly variant: string;

method fromObject

fromObject: (de: Deserializer, obj: JSONOutput.SignatureReflection) => void;

method isSignature

isSignature: () => this is SignatureReflection;

method toObject

toObject: (serializer: Serializer) => JSONOutput.SignatureReflection;

method toString

toString: () => string;

Return a string representation of this reflection.

method traverse

traverse: (callback: TraverseCallback) => void;

class Slugger

class Slugger {}

Responsible for getting a unique anchor for elements within a page.

constructor

constructor(options: { lowercase: boolean });

method getSimilarAnchors

getSimilarAnchors: (anchor: string) => string[];

method hasAnchor

hasAnchor: (anchor: string) => boolean;

method slug

slug: (value: string) => string;

class SourceReference

class SourceReference {}

Represents references of reflections to their defining source files.
See Also
- DeclarationReflection.sources

constructor

constructor(fileName: string, line: number, character: number);

property character

character: number;

The index of the character that emitted the declaration.

property fileName

fileName: string;

The filename of the source file.

property line

line: number;

The one based number of the line that emitted the declaration.

property url

url?: string;

URL for displaying the source file.

method equals

equals: (other: SourceReference) => boolean;

method fromObject

fromObject: (_de: Deserializer, obj: JSONOutput.SourceReference) => void;

method toObject

toObject: () => JSONOutput.SourceReference;

class StructureDirRouter

class StructureDirRouter extends StructureRouter {}

Router which places reflections in folders according to the module structure, but creates each page as /index.html to allow for clean URLs. Routers

method buildChildPages

protected buildChildPages: (
    reflection: Reflection,
    outPages: PageDefinition[]
) => void;

method getFullUrl

getFullUrl: (refl: Reflection) => string;

method relativeUrl

relativeUrl: (from: Reflection, to: Reflection) => string;

class StructureRouter

class StructureRouter extends BaseRouter {}

Router which places reflections in folders according to the module structure. Routers

method getIdealBaseName

protected getIdealBaseName: (reflection: Reflection) => string;

class TemplateLiteralType

class TemplateLiteralType extends Type {}

TS 4.1 template literal types
type Z = `${'a' | 'b'}${'a' | 'b'}`
Types

constructor

constructor(head: string, tail: [SomeType, string][]);

property head

head: string;

property tail

tail: [SomeType, string][];

property type

readonly type: string;

method getTypeString

protected getTypeString: () => string;

method needsParenthesis

needsParenthesis: () => boolean;

method toObject

toObject: (serializer: Serializer) => JSONOutput.TemplateLiteralType;

class Theme

abstract class Theme extends RendererComponent {}

Base class of all themes.
The theme class determines how a page is rendered. It is loosely coupled with a router class instance which is also created by the Renderer class.

method postRender

postRender: (_event: RendererEvent) => Promise<void>;

Optional hook to call post-render jobs

method preRender

preRender: (_event: RendererEvent) => Promise<void>;

Optional hook to call pre-render jobs

method render

abstract render: (event: PageEvent) => string;

Renders the provided page to a string, which will be written to disk by the Renderer

class TSConfigReader

class TSConfigReader implements OptionsReader {}

property name

name: string;

property order

order: number;

Note: Runs after the TypeDocReader.

property supportsPackages

supportsPackages: boolean;

method read

read: (
    container: Options,
    logger: Logger,
    cwd: string,
    usedFile?: (path: string) => void
) => void;

class TupleType

class TupleType extends Type {}

Represents a tuple type.
let value: [string, boolean];
Types

constructor

constructor(elements: SomeType[]);

Parameter elements
The ordered type elements of the tuple type.

property elements

elements: SomeType[];

property type

readonly type: string;

method getTypeString

protected getTypeString: () => string;

method needsParenthesis

needsParenthesis: () => boolean;

method toObject

toObject: (serializer: Serializer) => JSONOutput.TupleType;

class Type

abstract class Type {}

Base class of all type definitions. Types

property type

abstract readonly type: keyof TypeKindMap;

The type name identifier.

method estimatePrintWidth

estimatePrintWidth: () => number;

Return the estimated size of the type if it was all printed on one line.

method fromObject

fromObject: (_de: Deserializer, _obj: JSONOutput.SomeType) => void;

method getTypeString

protected abstract getTypeString: () => string;

Implementation method for toString. needsParenthesis will be used to determine if the returned string should be wrapped in parenthesis.

method needsParenthesis

abstract needsParenthesis: (context: TypeContext) => boolean;

method stringify

stringify: (context: TypeContext) => string;

method toObject

abstract toObject: (serializer: Serializer) => JSONOutput.SomeType;

method toString

toString: () => string;

Return a string representation of this type.

method visit

visit: {
    <T, A extends any[] = []>(visitor: TypeVisitor<T, A>, ...args: A): T;
    <T, A extends any[] = []>(
        visitor: Partial<TypeVisitor<T, A>>,
        ...args: A
    ): T;
};

Visit this type, returning the value returned by the visitor.

class TypeDocReader

class TypeDocReader implements OptionsReader {}

Obtains option values from typedoc.json

property name

name: string;

property order

order: number;

Should run before the tsconfig reader so that it can specify a tsconfig file to read.

property supportsPackages

supportsPackages: boolean;

method read

read: (
    container: Options,
    logger: Logger,
    cwd: string,
    usedFile: (path: string) => void
) => Promise<void>;

Read user configuration from a typedoc.json or typedoc.js configuration file.

class TypeOperatorType

class TypeOperatorType extends Type {}

Represents a type operator type.
class A {} class B<T extends keyof A> {}
Types

constructor

constructor(target: SomeType, operator: 'keyof' | 'unique' | 'readonly');

property operator

operator: 'keyof' | 'unique' | 'readonly';

property target

target: SomeType;

property type

readonly type: string;

method getTypeString

protected getTypeString: () => string;

method needsParenthesis

needsParenthesis: (context: TypeContext) => boolean;

method toObject

toObject: (serializer: Serializer) => JSONOutput.TypeOperatorType;

class TypeParameterReflection

class TypeParameterReflection extends Reflection {}

Reflections

constructor

constructor(
    name: string,
    parent: Reflection,
    varianceModifier: VarianceModifier
);

property default

default?: SomeType;

property parent

parent?: DeclarationReflection | SignatureReflection;

property type

type?: SomeType;

property varianceModifier

varianceModifier?: VarianceModifier;

property variant

readonly variant: string;

method fromObject

fromObject: (de: Deserializer, obj: JSONOutput.TypeParameterReflection) => void;

method isTypeParameter

isTypeParameter: () => this is TypeParameterReflection;

method toObject

toObject: (serializer: Serializer) => JSONOutput.TypeParameterReflection;

method traverse

traverse: (_callback: TraverseCallback) => void;

class UnionType

class UnionType extends Type {}

Represents an union type.
let value: string | string[];
Types

constructor

constructor(types: SomeType[]);

property elementSummaries

elementSummaries?: CommentDisplayPart[][];

If present, there should be as many items in this array as there are items in the types array.
This member is only valid on unions which are on with a ReflectionKind kind of TypeAlias. Specifying it on any other union is undefined behavior.

property type

readonly type: string;

property types

types: SomeType[];

method fromObject

fromObject: (de: Deserializer, obj: JSONOutput.UnionType) => void;

method getTypeString

protected getTypeString: () => string;

method needsParenthesis

needsParenthesis: (context: TypeContext) => boolean;

method toObject

toObject: (serializer: Serializer) => JSONOutput.UnionType;

class UnknownType

class UnknownType extends Type {}

Represents all unknown types that cannot be converted by TypeDoc. Types

constructor

constructor(name: string);

property name

name: string;

A string representation of the type as returned from TypeScript compiler.

property type

readonly type: string;

method getTypeString

protected getTypeString: () => string;

method needsParenthesis

needsParenthesis: (context: TypeContext) => boolean;

Always returns true if not at the root level, we have no idea what's in here, so wrap it in parenthesis to be extra safe.

method toObject

toObject: () => JSONOutput.UnknownType;

class ValidatingFileRegistry

class ValidatingFileRegistry extends FileRegistry {}

constructor

constructor(basePath?: NormalizedPath);

property basePath

basePath: NormalizedPath;

method fromObject

fromObject: (de: Deserializer, obj: JSONOutput.FileRegistry) => void;

method register

register: (
    sourcePath: NormalizedPath,
    relativePath: NormalizedPath
) => { target: FileId; anchor: string | undefined } | undefined;

Interfaces

interface ApplicationEvents

interface ApplicationEvents {}

property bootstrapEnd

bootstrapEnd: [Application];

property reviveProject

reviveProject: [ProjectReflection];

property validateProject

validateProject: [ProjectReflection];

interface ArrayDeclarationOption

interface ArrayDeclarationOption extends DeclarationOptionBase {}

property defaultValue

defaultValue?: readonly string[];

If not specified defaults to an empty array.

property type

type:
    | ParameterType.Array
    | ParameterType.PathArray
    | ParameterType.ModuleArray
    | ParameterType.PluginArray;

property validate

validate?: (value: string[]) => void;

An optional validation function that validates a potential value of this option. The function must throw an Error if the validation fails and should do nothing otherwise.

interface BooleanDeclarationOption

interface BooleanDeclarationOption extends DeclarationOptionBase {}

property defaultValue

defaultValue?: boolean;

If not specified defaults to false.

property type

type: ParameterType.Boolean;

interface CommentParserConfig

interface CommentParserConfig {}

property blockTags

blockTags: Set<string>;

property commentStyle

commentStyle: CommentStyle;

property inlineTags

inlineTags: Set<string>;

property jsDocCompatibility

jsDocCompatibility: JsDocCompatibility;

property modifierTags

modifierTags: Set<string>;

property suppressCommentWarningsInDeclarationFiles

suppressCommentWarningsInDeclarationFiles: boolean;

property useTsLinkResolution

useTsLinkResolution: boolean;

interface ConverterEvents

interface ConverterEvents {}

property begin

begin: [Context];

property createDeclaration

createDeclaration: [Context, DeclarationReflection];

property createDocument

createDocument: [undefined, DocumentReflection];

property createParameter

createParameter: [Context, ParameterReflection, ts.Node?];

property createProject

createProject: [Context, ProjectReflection];

property createSignature

createSignature: [
    Context,
    SignatureReflection,
    (
        | ts.SignatureDeclaration
        | ts.IndexSignatureDeclaration
        | ts.JSDocSignature
    )?,
    ts.Signature?
];

property createTypeParameter

createTypeParameter: [
    Context,
    TypeParameterReflection,
    ts.TypeParameterDeclaration?
];

property end

end: [Context];

property resolveBegin

resolveBegin: [Context];

property resolveEnd

resolveEnd: [Context];

property resolveReflection

resolveReflection: [Context, Reflection];

interface DeclarationHierarchy

interface DeclarationHierarchy {}

Stores hierarchical type data.
See Also
- DeclarationReflection.typeHierarchy

property isTarget

isTarget?: boolean;

Is this the entry containing the target type?

property next

next?: DeclarationHierarchy;

The next hierarchy level.

property types

types: SomeType[];

The types represented by this node in the hierarchy.

interface DeclarationOptionBase

interface DeclarationOptionBase {}

property configFileOnly

configFileOnly?: boolean;

If set, this option will be omitted from --help, and attempting to specify it on the command line will produce an error.

property help

help: NeverIfInternal<string> | (() => string);

The help text to be displayed to the user when --help is passed.
This may be a string, which will be presented directly, or a function, which will be called so that option help can be translated into the user specified locale.

property name

name: string;

The option name.

property type

type?: ParameterType;

The parameter type, used to convert user configuration values into the expected type. If not set, the type will be a string.

interface Deserializable

interface Deserializable<T> {}

method fromObject

fromObject: (d: Deserializer, o: T) => void;

interface DeserializerComponent

interface DeserializerComponent {}

property priority

priority: number;

method fromObject

fromObject: (model: unknown, obj: unknown) => void;

method supports

supports: (model: unknown, obj: unknown) => boolean;

interface DocumentationEntryPoint

interface DocumentationEntryPoint {}

property displayName

displayName: string;

property program

program: ts.Program;

property sourceFile

sourceFile: ts.SourceFile;

interface FlagsDeclarationOption

interface FlagsDeclarationOption<T extends Record<string, boolean>>
    extends DeclarationOptionBase {}

property defaults

defaults: T;

All of the possible flags, with their default values set.

property type

type: ParameterType.Flags;

interface Icons

interface Icons extends Record<ReflectionKind, () => JSX.Element> {}

method alertCaution

alertCaution: () => JSX.Element;

method alertImportant

alertImportant: () => JSX.Element;

method alertNote

alertNote: () => JSX.Element;

method alertTip

alertTip: () => JSX.Element;

method alertWarning

alertWarning: () => JSX.Element;

method anchor

anchor: () => JSX.Element;

method checkbox

checkbox: () => JSX.Element;

method chevronDown

chevronDown: () => JSX.Element;

method chevronSmall

chevronSmall: () => JSX.Element;

Deprecated

method folder

folder: () => JSX.Element;

menu: () => JSX.Element;

method search

search: () => JSX.Element;

interface InlineTagDisplayPart

interface InlineTagDisplayPart {}

Represents an inline tag like {@link Foo}
The @link, @linkcode, and @linkplain tags may have a target property set indicating which reflection/url they link to. They may also have a tsLinkText property which includes the part of the text which TypeScript thinks should be displayed as the link text. Comments

property kind

kind: 'inline-tag';

property tag

tag: TagString;

property target

target?: Reflection | string | ReflectionSymbolId;

property text

text: string;

property tsLinkText

tsLinkText?: string;

interface MapDeclarationOption

interface MapDeclarationOption<T> extends DeclarationOptionBase {}

property defaultValue

defaultValue: T;

Unlike the rest of the option types, there is no sensible generic default for mapped option types. The default value for a mapped type must be specified.

property map

map: Map<string, T> | Record<string | number, T>;

Maps a given value to the option type. The map type may be a TypeScript enum. In that case, when generating an error message for a mismatched key, the numeric keys will not be listed.

property type

type: ParameterType.Map;

interface MixedDeclarationOption

interface MixedDeclarationOption extends DeclarationOptionBase {}

property defaultValue

defaultValue?: unknown;

If not specified defaults to undefined.

property type

type: ParameterType.Mixed;

property validate

validate?: (value: unknown) => void;

An optional validation function that validates a potential value of this option. The function must throw an Error if the validation fails and should do nothing otherwise.

interface NavigationElement

interface NavigationElement {}

property children

children?: NavigationElement[];

property class

class?: string;

property icon

icon?: string | number;

property kind

kind?: ReflectionKind;

property path

path?: string;

property text

text: string;

interface NumberDeclarationOption

interface NumberDeclarationOption extends DeclarationOptionBase {}

property defaultValue

defaultValue?: number;

If not specified defaults to 0.

property maxValue

maxValue?: number;

Highest possible value.

property minValue

minValue?: number;

Lowest possible value.

property type

type: ParameterType.Number;

property validate

validate?: (value: number) => void;

An optional validation function that validates a potential value of this option. The function must throw an Error if the validation fails and should do nothing otherwise.

interface ObjectDeclarationOption

interface ObjectDeclarationOption extends DeclarationOptionBase {}

property defaultValue

defaultValue?: unknown;

If not specified defaults to undefined.

property type

type: ParameterType.Object;

property validate

validate?: (value: unknown) => void;

An optional validation function that validates a potential value of this option. The function must throw an Error if the validation fails and should do nothing otherwise.

interface OptionsReader

interface OptionsReader {}

Describes an option reader that discovers user configuration and converts it to the TypeDoc format.

property name

readonly name: string;

The name of this reader so that it may be removed by plugins without the plugin accessing the instance performing the read. Multiple readers may have the same name.

property order

readonly order: number;

Readers will be processed according to their orders. A higher order indicates that the reader should be called *later*.
Note that to preserve expected behavior, the argv reader must have both the lowest order so that it may set the location of config files used by other readers and the highest order so that it can override settings from lower order readers.

property supportsPackages

readonly supportsPackages: boolean;

Flag to indicate that this reader should be included in sub-options objects created to read options for packages mode.

method read

read: (
    container: Options,
    logger: Logger,
    cwd: string,
    usedFile: (file: string) => void
) => void | Promise<void>;

Read options from the reader's source and place them in the options parameter. Options without a declared name may be treated as if they were declared with type ParameterType.Mixed. Options which have been declared must be converted to the correct type. As an alternative to doing this conversion in the reader, the reader may use Options.setValue, which will correctly convert values.
Parameter container
the options container that provides declarations
Parameter logger
logger to be used to report errors
Parameter cwd
the directory which should be treated as the current working directory for option file discovery
Parameter usedFile
a callback to track files that were read or whose existence was checked, for purposes of restarting a build when watching files

interface PageDefinition

interface PageDefinition<out Model extends RouterTarget = RouterTarget> {}

property kind

readonly kind: PageKind;

property model

readonly model: Model;

property url

readonly url: string;

interface PageHeading

interface PageHeading {}

property classes

classes?: string;

property kind

kind?: ReflectionKind;

property level

level?: number;

property link

link: string;

property text

text: string;

interface ParameterTypeToOptionTypeMap

interface ParameterTypeToOptionTypeMap {}

property [ParameterType.Array]

[ParameterType.Array]: string[];

property [ParameterType.Boolean]

[ParameterType.Boolean]: boolean;

property [ParameterType.Flags]

[ParameterType.Flags]: Record<string, boolean>;

property [ParameterType.GlobArray]

[ParameterType.GlobArray]: GlobString[];

property [ParameterType.Map]

[ParameterType.Map]: unknown;

property [ParameterType.Mixed]

[ParameterType.Mixed]: unknown;

property [ParameterType.ModuleArray]

[ParameterType.ModuleArray]: NormalizedPathOrModule[];

property [ParameterType.Number]

[ParameterType.Number]: number;

property [ParameterType.Object]

[ParameterType.Object]: unknown;

property [ParameterType.Path]

[ParameterType.Path]: NormalizedPath;

property [ParameterType.PathArray]

[ParameterType.PathArray]: NormalizedPath[];

property [ParameterType.PluginArray]

[ParameterType.PluginArray]: Array<
    NormalizedPathOrModule | ((app: Application) => void | Promise<void>)
>;

property [ParameterType.String]

[ParameterType.String]: string;

property [ParameterType.UrlOrPath]

[ParameterType.UrlOrPath]: NormalizedPath | string;

interface ReflectionVariant

interface ReflectionVariant {}

A map of known Reflection concrete subclasses. This is used during deserialization to reconstruct serialized objects.

property declaration

declaration: DeclarationReflection;

property document

document: DocumentReflection;

property param

param: ParameterReflection;

property project

project: ProjectReflection;

property reference

reference: ReferenceReflection;

property signature

signature: SignatureReflection;

property typeParam

typeParam: TypeParameterReflection;

interface RelativeLinkDisplayPart

interface RelativeLinkDisplayPart {}

Represents a reference to a path relative to where the comment resides. This is used to detect and copy relative image links.
Use FileRegistry to determine what path on disc this refers to.
This is used for relative links within comments/documents. It is used to mark pieces of text which need to be replaced to make links work properly. Comments

property kind

kind: 'relative-link';

property target

target: FileId | undefined;

A link to either some document outside of the project or a reflection. This may be undefined if the relative path does not exist.

property targetAnchor

targetAnchor: string | undefined;

Anchor within the target page, validated after rendering if possible

property text

text: string;

The original relative text from the parsed comment.

interface RendererEvents

interface RendererEvents {}

property beginPage

beginPage: [PageEvent];

property beginRender

beginRender: [RendererEvent];

property endPage

endPage: [PageEvent];

property endRender

endRender: [RendererEvent];

property parseMarkdown

parseMarkdown: [MarkdownEvent];

property prepareIndex

prepareIndex: [IndexEvent];

interface RendererHooks

interface RendererHooks {}

Describes the hooks available to inject output in the default theme. If the available hooks don't let you put something where you'd like, please open an issue!

property "body.begin"

'body.begin': [DefaultThemeRenderContext];

Applied immediately after the opening <body> tag.

property "body.end"

'body.end': [DefaultThemeRenderContext];

Applied immediately before the closing </body> tag.

property "comment.afterTags"

'comment.afterTags': [DefaultThemeRenderContext, Comment, Reflection];

Applied immediately after a comment's tags are rendered.
This may be used to set Models.CommentTag.skipRendering on any tags which should not be rendered as this hook is called before the tags are actually rendered.

property "comment.beforeTags"

'comment.beforeTags': [DefaultThemeRenderContext, Comment, Reflection];

Applied immediately before a comment's tags are rendered.
This may be used to set Models.CommentTag.skipRendering on any tags which should not be rendered.

property "content.begin"

'content.begin': [DefaultThemeRenderContext];

Applied immediately before the main template.

property "content.end"

'content.end': [DefaultThemeRenderContext];

Applied immediately after the main template.

'footer.begin': [DefaultThemeRenderContext];

Applied immediately before the "Generated by TypeDoc" link in the footer.

'footer.end': [DefaultThemeRenderContext];

Applied immediately after the "Generated by TypeDoc" link in the footer.

property "head.begin"

'head.begin': [DefaultThemeRenderContext];

Applied immediately after the opening <head> tag.

property "head.end"

'head.end': [DefaultThemeRenderContext];

Applied immediately before the closing </head> tag.

property "pageSidebar.begin"

'pageSidebar.begin': [DefaultThemeRenderContext];

Applied immediately before calling context.pageSidebar.

property "pageSidebar.end"

'pageSidebar.end': [DefaultThemeRenderContext];

Applied immediately after calling context.pageSidebar.

'sidebar.begin': [DefaultThemeRenderContext];

Applied immediately before calling context.sidebar.

'sidebar.end': [DefaultThemeRenderContext];

Applied immediately after calling context.sidebar.

interface Router

interface Router {}

Interface which routers must conform to.

method baseRelativeUrl

baseRelativeUrl: (from: RouterTarget, target: string) => string;

Should return a URL relative to the project base. This is used for determining links to items in the assets folder.

method buildPages

buildPages: (project: ProjectReflection) => PageDefinition[];

Should return a list of pages which should be rendered. This will be called once per render.

method getAnchor

getAnchor: (refl: RouterTarget) => string | undefined;

Gets an anchor for this target within its containing page. May be undefined if this target owns its own page.

method getFullUrl

getFullUrl: (refl: RouterTarget) => string;

Get the full URL to the target. In TypeDoc's default router this is equivalent to relativeUrl(project, refl), but this might not be the case for custom routers which place the project somewhere else besides index.html.
The URL returned by this by the frontend JS when building dynamic URLs for the search, full hierarchy, and navigation components.

method getLinkTargets

getLinkTargets: () => RouterTarget[];

Get a list of all targets which can be linked to. This is used for creating the search index.

method getSlugger

getSlugger: (reflection: RouterTarget) => Slugger;

Responsible for getting a slugger for the given target. If a target is not associated with a page, the slugger for the parent target should be returned instead.

method hasOwnDocument

hasOwnDocument: (refl: RouterTarget) => boolean;

Returns true if the target has its own page, false if embedded within another page.

method hasUrl

hasUrl: (target: RouterTarget) => boolean;

Can be used to check if the target can be linked to.

method relativeUrl

relativeUrl: (from: RouterTarget, to: RouterTarget) => string;

Should return a URL which when clicked on the page containing from takes the user to the page/anchor containing to.

interface SerializerComponent

interface SerializerComponent<T extends object> {}

Represents Serializer plugin component.
Like Converter plugins each Serializer plugin defines a predicate that instructs if an object can be serialized by it. This is done dynamically at runtime via a supports method.

property priority

readonly priority: number;

The priority this serializer should be executed with. A higher priority means the Serializer will be applied earlier.

method supports

supports: (item: unknown) => boolean;

Technically this should return item is T, but that doesn't play nicely with inference, so allow the looser boolean return type.
Parameter item

method toObject

toObject: (
    item: T,
    obj: Partial<ModelToObject<T>>,
    serializer: Serializer
) => Partial<ModelToObject<T>>;

interface SerializerEvents

interface SerializerEvents {}

property begin

begin: [SerializeEvent];

property end

end: [SerializeEvent];

interface StringDeclarationOption

interface StringDeclarationOption extends DeclarationOptionBase {}

property defaultValue

defaultValue?: string;

If not specified defaults to the empty string for all types.

property hint

hint?: ParameterHint;

An optional hint for the type of input expected, will be displayed in the help output.

property outputShortcut

outputShortcut?: string;

If specified, when this output is specified TypeDoc will automatically add an output to the outputs option whose name is the value of this property with the path set to the value of this option. Should only be used with type set to ParameterType.Path.
If any output shortcuts are set, the outputs option will be ignored.

property type

type?: ParameterType.String | ParameterType.Path | ParameterType.UrlOrPath;

Specifies the resolution strategy. If Path is provided, values will be resolved according to their location in a file. If String or no value is provided, values will not be resolved.

property validate

validate?: (value: string) => void;

An optional validation function that validates a potential value of this option. The function must throw an Error if the validation fails and should do nothing otherwise.

interface TranslatableStrings

interface TranslatableStrings extends BuiltinTranslatableStringArgs {}

### 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 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 1
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]; } }

interface TraverseCallback

interface TraverseCallback {}

call signature

(reflection: Reflection, property: TraverseProperty):
    | boolean
    | NeverIfInternal<void>;

May return false to bail out of any further iteration. To preserve backwards compatibility, if a function returns undefined, iteration must continue.

interface TypeDocOptionMap

interface TypeDocOptionMap {}

Describes all TypeDoc options. Used internally to provide better types when fetching options. External consumers should likely use TypeDocOptions instead.
If writing a plugin, you may find it useful to use declaration merging to add your options to this interface so that you have autocomplete when using app.options.getValue.
declare module "typedoc" { export interface TypeDocOptionMap { pluginOption: string[]; } }

property alwaysCreateEntryPointModule

alwaysCreateEntryPointModule: boolean;

property basePath

basePath: NormalizedPath;

property blockTags

blockTags: TagString[];

property cacheBust

cacheBust: boolean;

property cascadedModifierTags

cascadedModifierTags: TagString[];

property categorizeByGroup

categorizeByGroup: boolean;

property categoryOrder

categoryOrder: string[];

property cleanOutputDir

cleanOutputDir: boolean;

property cname

cname: string;

property commentStyle

commentStyle: typeof CommentStyle;

property compilerOptions

compilerOptions: unknown;

property customCss

customCss: NormalizedPath;

property customFooterHtml

customFooterHtml: string;

property customFooterHtmlDisableWrapper

customFooterHtmlDisableWrapper: boolean;

property customJs

customJs: NormalizedPath;

property darkHighlightTheme

darkHighlightTheme: ShikiTheme;

property defaultCategory

defaultCategory: string;

property disableGit

disableGit: boolean;

property disableSources

disableSources: boolean;

property displayBasePath

displayBasePath: NormalizedPath;

property emit

emit: typeof EmitStrategy;

property entryPoints

entryPoints: GlobString[];

property entryPointStrategy

entryPointStrategy: typeof EntryPointStrategy;

property exclude

exclude: GlobString[];

property excludeCategories

excludeCategories: string[];

property excludeExternals

excludeExternals: boolean;

property excludeInternal

excludeInternal: boolean;

property excludeNotDocumented

excludeNotDocumented: boolean;

property excludeNotDocumentedKinds

excludeNotDocumentedKinds: ReflectionKind.KindString[];

property excludePrivate

excludePrivate: boolean;

property excludeProtected

excludeProtected: boolean;

property excludeReferences

excludeReferences: boolean;

property excludeTags

excludeTags: TagString[];

property externalPattern

externalPattern: GlobString[];

property externalSymbolLinkMappings

externalSymbolLinkMappings: ManuallyValidatedOption<
    Record<string, Record<string, string>>
>;

property favicon

favicon: NormalizedPath;

property githubPages

githubPages: boolean;

property gitRemote

gitRemote: string;

property gitRevision

gitRevision: string;

property groupOrder

groupOrder: string[];

property groupReferencesByType

groupReferencesByType: boolean;

property headings

headings: {
    readme: boolean;
    document: boolean;
};

property help

help: boolean;

property hideGenerator

hideGenerator: boolean;

property highlightLanguages

highlightLanguages: string[];

property hostedBaseUrl

hostedBaseUrl: string;

property html

html: NormalizedPath;

property ignoredHighlightLanguages

ignoredHighlightLanguages: string[];

property includeHierarchySummary

includeHierarchySummary: boolean;

property includeVersion

includeVersion: boolean;

property inlineTags

inlineTags: TagString[];

property intentionallyNotDocumented

intentionallyNotDocumented: string[];

property intentionallyNotExported

intentionallyNotExported: string[];

property jsDocCompatibility

jsDocCompatibility: JsDocCompatibility;

property json

json: NormalizedPath;

property kindSortOrder

kindSortOrder: ReflectionKind.KindString[];

property lang

lang: string;

property lightHighlightTheme

lightHighlightTheme: ShikiTheme;

property locales

locales: ManuallyValidatedOption<Record<string, Record<string, string>>>;

property logLevel

logLevel: typeof LogLevel;

property markdownItLoader

markdownItLoader: ManuallyValidatedOption<(parser: any) => void>;

Will be called when TypeDoc is setting up the markdown parser to use to render markdown. Can be used to add markdown-it plugins to the parser with code like this:

// typedoc.config.mjs
import iterator from "markdown-it-for-inline";
export default {
    /** @param {MarkdownIt} parser *\/
    markdownItLoader(parser) {
        parser.use(iterator, "foo_replace", "text", function(tokens, idx) {
            tokens[idx].content = tokens[idx].content.replace(/foo/g, 'bar');
        });
    }
}

Note: Unfortunately, markdown-it doesn't ship its own types, so parser isn't strictly typed here.

property markdownItOptions

markdownItOptions: ManuallyValidatedOption<Record<string, unknown>>;

property markdownLinkExternal

markdownLinkExternal: boolean;

property maxTypeConversionDepth

maxTypeConversionDepth: number;

property modifierTags

modifierTags: TagString[];

property name

name: string;

navigation: {
    includeCategories: boolean;
    includeGroups: boolean;
    includeFolders: boolean;
    compactFolders: boolean;
    excludeReferences: boolean;
};

property navigationLeaves

navigationLeaves: string[];

property navigationLinks

navigationLinks: ManuallyValidatedOption<Record<string, string>>;

property notRenderedTags

notRenderedTags: TagString[];

property options

options: NormalizedPath;

property out

out: NormalizedPath;

property outputs

outputs: ManuallyValidatedOption<Array<OutputSpecification>>;

property packageOptions

packageOptions: ManuallyValidatedOption<TypeDocPackageOptions>;

property packagesRequiringDocumentation

packagesRequiringDocumentation: string[];

property plugin

plugin: NormalizedPathOrModuleOrFunction[];

property preserveLinkText

preserveLinkText: boolean;

property preserveWatchOutput

preserveWatchOutput: boolean;

property pretty

pretty: boolean;

property projectDocuments

projectDocuments: GlobString[];

property readme

readme: string;

property requiredToBeDocumented

requiredToBeDocumented: ReflectionKind.KindString[];

property router

router: string;

property searchCategoryBoosts

searchCategoryBoosts: ManuallyValidatedOption<Record<string, number>>;

property searchGroupBoosts

searchGroupBoosts: ManuallyValidatedOption<Record<string, number>>;

property searchInComments

searchInComments: boolean;

property searchInDocuments

searchInDocuments: boolean;

property showConfig

showConfig: boolean;

property sidebarLinks

sidebarLinks: ManuallyValidatedOption<Record<string, string>>;

property skipErrorChecking

skipErrorChecking: boolean;

property sluggerConfiguration

sluggerConfiguration: {
    lowercase: boolean;
};

property sort

sort: SortStrategy[];

property sortEntryPoints

sortEntryPoints: boolean;

property sourceLinkExternal

sourceLinkExternal: boolean;

property sourceLinkTemplate

sourceLinkTemplate: string;

property suppressCommentWarningsInDeclarationFiles

suppressCommentWarningsInDeclarationFiles: boolean;

property theme

theme: string;

property titleLink

titleLink: string;

property treatValidationWarningsAsErrors

treatValidationWarningsAsErrors: boolean;

property treatWarningsAsErrors

treatWarningsAsErrors: boolean;

property tsconfig

tsconfig: NormalizedPath;

property typePrintWidth

typePrintWidth: number;

property useFirstParagraphOfCommentAsSummary

useFirstParagraphOfCommentAsSummary: boolean;

property useHostedBaseUrlForAbsoluteLinks

useHostedBaseUrlForAbsoluteLinks: boolean;

property useTsLinkResolution

useTsLinkResolution: boolean;

property validation

validation: ValidationOptions;

property version

version: boolean;

property visibilityFilters

visibilityFilters: ManuallyValidatedOption<{
    protected?: boolean;
    private?: boolean;
    inherited?: boolean;
    external?: boolean;
    [tag: TagString]: boolean;
}>;

property watch

watch: boolean;

interface TypeKindMap

interface TypeKindMap {}

Types

property array

array: ArrayType;

property conditional

conditional: ConditionalType;

property indexedAccess

indexedAccess: IndexedAccessType;

property inferred

inferred: InferredType;

property intersection

intersection: IntersectionType;

property intrinsic

intrinsic: IntrinsicType;

property literal

literal: LiteralType;

property mapped

mapped: MappedType;

property namedTupleMember

namedTupleMember: NamedTupleMember;

property optional

optional: OptionalType;

property predicate

predicate: PredicateType;

property query

query: QueryType;

property reference

reference: ReferenceType;

property reflection

reflection: ReflectionType;

property rest

rest: RestType;

property templateLiteral

templateLiteral: TemplateLiteralType;

property tuple

tuple: TupleType;

property typeOperator

typeOperator: TypeOperatorType;

property union

union: UnionType;

property unknown

unknown: UnknownType;

Enums

enum ParameterHint

enum ParameterHint {
    File = 0,
    Directory = 1,
}

member Directory

Directory = 1

member File

File = 0

enum ParameterType

enum ParameterType {
    String = 0,
    Path = 1,
    UrlOrPath = 2,
    Number = 3,
    Boolean = 4,
    Map = 5,
    Mixed = 6,
    Array = 7,
    PathArray = 8,
    ModuleArray = 9,
    GlobArray = 11,
    Object = 12,
    Flags = 13,
}

member Array

Array = 7

member Boolean

Boolean = 4

member Flags

Flags = 13

An object with true/false flags

member GlobArray

GlobArray = 11

Relative to the config directory.

member Map

Map = 5

member Mixed

Mixed = 6

member ModuleArray

ModuleArray = 9

Resolved according to the config directory if it starts with .
Deprecated
since 0.28.8, will be removed in 0.29

member Number

Number = 3

member Object

Object = 12

An object which partially merges user-set values into the defaults.

member Path

Path = 1

Resolved according to the config directory.

member PathArray

PathArray = 8

Resolved according to the config directory.

member String

String = 0

member UrlOrPath

UrlOrPath = 2

Resolved according to the config directory unless it starts with https?://

enum ReflectionFlag

enum ReflectionFlag {
    None = 0,
    Private = 1,
    Protected = 2,
    Public = 4,
    Static = 8,
    External = 16,
    Optional = 32,
    Rest = 64,
    Abstract = 128,
    Const = 256,
    Readonly = 512,
    Inherited = 1024,
}

member Abstract

Abstract = 128

member Const

Const = 256

member External

External = 16

member Inherited

Inherited = 1024

member None

None = 0

member Optional

Optional = 32

member Private

Private = 1

member Protected

Protected = 2

member Public

Public = 4

member Readonly

Readonly = 512

member Rest

Rest = 64

member Static

Static = 8

enum ReflectionKind

enum ReflectionKind {
    Project = 1,
    Module = 2,
    Namespace = 4,
    Enum = 8,
    EnumMember = 16,
    Variable = 32,
    Function = 64,
    Class = 128,
    Interface = 256,
    Constructor = 512,
    Property = 1024,
    Method = 2048,
    CallSignature = 4096,
    IndexSignature = 8192,
    ConstructorSignature = 16384,
    Parameter = 32768,
    TypeLiteral = 65536,
    TypeParameter = 131072,
    Accessor = 262144,
    GetSignature = 524288,
    SetSignature = 1048576,
    TypeAlias = 2097152,
    Reference = 4194304,
    Document = 8388608,
}

Defines the available reflection kinds. Reflections

member Accessor

Accessor = 262144

member CallSignature

CallSignature = 4096

member Class

Class = 128

member Constructor

Constructor = 512

member ConstructorSignature

ConstructorSignature = 16384

member Document

Document = 8388608

Generic non-ts content to be included in the generated docs as its own page.

member Enum

Enum = 8

member EnumMember

EnumMember = 16

member Function

Function = 64

member GetSignature

GetSignature = 524288

member IndexSignature

IndexSignature = 8192

member Interface

Interface = 256

member Method

Method = 2048

member Module

Module = 2

member Namespace

Namespace = 4

member Parameter

Parameter = 32768

member Project

Project = 1

member Property

Property = 1024

member Reference

Reference = 4194304

member SetSignature

SetSignature = 1048576

member TypeAlias

TypeAlias = 2097152

member TypeLiteral

TypeLiteral = 65536

member TypeParameter

TypeParameter = 131072

member Variable

Variable = 32

enum TraverseProperty

enum TraverseProperty {
    Children = 0,
    Documents = 1,
    Parameters = 2,
    TypeLiteral = 3,
    TypeParameter = 4,
    Signatures = 5,
    IndexSignature = 6,
    GetSignature = 7,
    SetSignature = 8,
}

member Children

Children = 0

member Documents

Documents = 1

member GetSignature

GetSignature = 7

member IndexSignature

IndexSignature = 6

member Parameters

Parameters = 2

member SetSignature

SetSignature = 8

member Signatures

Signatures = 5

member TypeLiteral

TypeLiteral = 3

member TypeParameter

TypeParameter = 4

Type Aliases

type CommentDisplayPart

type CommentDisplayPart =
    /**
     * Represents a plain text portion of the comment, may contain markdown
     */
    | {
          kind: 'text';
          text: string;
      }
    /**
     * Represents a code block separated out form the plain text entry so
     * that TypeDoc knows to skip it when parsing relative links and inline tags.
     */
    | {
          kind: 'code';
          text: string;
      }
    | InlineTagDisplayPart
    | RelativeLinkDisplayPart;

Represents a parsed piece of a comment. Comments
See Also
- JSONOutput.CommentDisplayPart

type CommentStyle

type CommentStyle = (typeof CommentStyle)[keyof typeof CommentStyle];

type DeclarationOption

type DeclarationOption =
    | StringDeclarationOption
    | NumberDeclarationOption
    | BooleanDeclarationOption
    | MixedDeclarationOption
    | ObjectDeclarationOption
    | MapDeclarationOption<unknown>
    | ArrayDeclarationOption
    | GlobArrayDeclarationOption
    | FlagsDeclarationOption<Record<string, boolean>>;

type DeclarationOptionToOptionType

type DeclarationOptionToOptionType<T extends DeclarationOption> =
    T extends MapDeclarationOption<infer U>
        ? U
        : T extends FlagsDeclarationOption<infer U>
        ? U
        : ParameterTypeToOptionTypeMap[Exclude<T['type'], undefined>];

type EntryPointStrategy

type EntryPointStrategy =
    (typeof EntryPointStrategy)[keyof typeof EntryPointStrategy];

type ExternalResolveResult

type ExternalResolveResult = {
    target: string;
    caption?: string;
};

type ExternalSymbolResolver

type ExternalSymbolResolver = (
    ref: DeclarationReference,
    refl: Reflection,
    part: Readonly<CommentDisplayPart> | undefined,
    symbolId: ReflectionSymbolId | undefined
) => ExternalResolveResult | string | undefined;

Parameter ref
Parsed declaration reference to resolve. This may be created automatically for some symbol, or parsed from user input.
Parameter refl
Reflection that contains the resolved link
Parameter part
If the declaration reference was created from a comment, the originating part.
Parameter symbolId
If the declaration reference was created from a symbol, or useTsLinkResolution is turned on and TypeScript resolved the link to some symbol, the ID of that symbol.

type FileId

type FileId = number & {
    __mediaIdBrand: never;
};

type JsDocCompatibility

type JsDocCompatibility = {
    /**
     * If set, TypeDoc will treat `@example` blocks as code unless they contain a code block.
     * On by default, this is how VSCode renders blocks.
     */
    exampleTag: boolean;
    /**
     * If set, TypeDoc will treat `@default` blocks as code unless they contain a code block.
     * On by default, this is how VSCode renders blocks.
     */
    defaultTag: boolean;
    /**
     * If set, TypeDoc will warn if a `@inheritDoc` tag is spelled without TSDoc capitalization
     * (i.e. `@inheritdoc`). On by default.
     */
    inheritDocTag: boolean;
    /**
     * If set, TypeDoc will not emit warnings about unescaped `{` and `}` characters encountered
     * when parsing a comment. On by default.
     */
    ignoreUnescapedBraces: boolean;
};

type KeyToDeclaration

type KeyToDeclaration<K extends keyof TypeDocOptionMap> =
    TypeDocOptionMap[K] extends boolean
        ? BooleanDeclarationOption
        : TypeDocOptionMap[K] extends string | NormalizedPath
        ? StringDeclarationOption
        : TypeDocOptionMap[K] extends number
        ? NumberDeclarationOption
        : TypeDocOptionMap[K] extends GlobString[]
        ? GlobArrayDeclarationOption
        : TypeDocOptionMap[K] extends
              | string[]
              | NormalizedPath[]
              | NormalizedPathOrModule[]
              | NormalizedPathOrModuleOrFunction[]
        ? ArrayDeclarationOption
        : unknown extends TypeDocOptionMap[K]
        ? MixedDeclarationOption | ObjectDeclarationOption
        : TypeDocOptionMap[K] extends ManuallyValidatedOption<unknown>
        ?
              | (MixedDeclarationOption & {
                    validate(value: unknown, i18n: TranslationProxy): void;
                })
              | (ObjectDeclarationOption & {
                    validate(value: unknown, i18n: TranslationProxy): void;
                })
        : TypeDocOptionMap[K] extends Record<string, boolean>
        ? FlagsDeclarationOption<TypeDocOptionMap[K]>
        : TypeDocOptionMap[K] extends Record<string | number, infer U>
        ? MapDeclarationOption<U>
        : never;

Converts a given TypeDoc option key to the type of the declaration expected.

type ManuallyValidatedOption

type ManuallyValidatedOption<T> = {
    __validated: T;
};

Wrapper type for values in TypeDocOptionMap which are represented with an unknown option type, but have a validation function that checks that they are the given type.

type OutputSpecification

type OutputSpecification = {
    name: string;
    path: string;
    options?: TypeDocOptions;
};

type PageKind

type PageKind = (typeof PageKind)[keyof typeof PageKind] | (string & {});

type ReflectionId

type ReflectionId = number & {
    __reflectionIdBrand: never;
};

Alias for a number which references a reflection. -1 may be used for an invalid reflection ID.

type ReflectionSymbolIdString

type ReflectionSymbolIdString = string & {
    readonly __reflectionSymbolId: unique symbol;
};

See ReflectionSymbolId

type ReflectionVisitor

type ReflectionVisitor = {
    [K in keyof ReflectionVariant]?: (refl: ReflectionVariant[K]) => void;
};

type RenderTemplate

type RenderTemplate<T> = (data: T) => JSX.Element | string;

Parameter data
the reflection to render
Returns
either a string to be written to the file, or an element to be serialized and then written.

type RouterTarget

type RouterTarget =
    | {
          name: string;
          parent: RouterTarget;
      }
    | Reflection;

A router target is something that may be linked to within a page. Notably, Reflection is compatible with this interface. TypeDoc supports non-reflection router targets, but does not currently create any.

type SomeReflection

type SomeReflection = ReflectionVariant[keyof ReflectionVariant];

type SomeType

type SomeType = TypeKindMap[keyof TypeKindMap];

Types

type SortStrategy

type SortStrategy = (typeof SORT_STRATEGIES)[number];

type TypeContext

type TypeContext = (typeof TypeContext)[keyof typeof TypeContext];

type TypeDocOptions

type TypeDocOptions = {
    [K in keyof TypeDocOptionMap]?: unknown extends TypeDocOptionMap[K]
        ? unknown
        : TypeDocOptionMap[K] extends ManuallyValidatedOption<
              infer ManuallyValidated
          >
        ? ManuallyValidated
        : TypeDocOptionMap[K] extends
              | NormalizedPath[]
              | NormalizedPathOrModule[]
              | NormalizedPathOrModuleOrFunction[]
              | GlobString[]
        ? string[]
        : TypeDocOptionMap[K] extends NormalizedPath
        ? string
        : TypeDocOptionMap[K] extends string | string[] | number | boolean
        ? TypeDocOptionMap[K]
        : TypeDocOptionMap[K] extends Record<string, boolean>
        ? Partial<TypeDocOptionMap[K]> | boolean
        : keyof TypeDocOptionMap[K] | TypeDocOptionMap[K][keyof TypeDocOptionMap[K]];
};

An interface describing all TypeDoc specific options. Generated from a map which contains more information about each option for better types when defining said options.

type TypeDocOptionValues

type TypeDocOptionValues = {
    [K in keyof TypeDocOptionMap]: unknown extends TypeDocOptionMap[K]
        ? unknown
        : TypeDocOptionMap[K] extends ManuallyValidatedOption<
              infer ManuallyValidated
          >
        ? ManuallyValidated
        : TypeDocOptionMap[K] extends
              | string
              | string[]
              | GlobString[]
              | NormalizedPathOrModule[]
              | NormalizedPathOrModuleOrFunction[]
              | number
              | boolean
              | Record<string, boolean>
        ? TypeDocOptionMap[K]
        : TypeDocOptionMap[K][keyof TypeDocOptionMap[K]];
};

Describes all TypeDoc specific options as returned by Options.getValue, this is slightly more restrictive than the TypeDocOptions since it does not allow both keys and values for mapped option types, and does not allow partials of flag values. It also does not mark keys as optional.

type TypeKind

type TypeKind = keyof TypeKindMap;

Types

type TypeVisitor

type TypeVisitor<T = void, A extends any[] = []> = {
    [K in TypeKind]: (type: TypeKindMap[K], ...args: A) => T;
};

type ValidationOptions

type ValidationOptions = {
    /**
     * If set, TypeDoc will produce warnings when a symbol is referenced by the documentation,
     * but is not included in the documentation.
     */
    notExported: boolean;
    /**
     * If set, TypeDoc will produce warnings about \{\@link\} tags which will produce broken links.
     */
    invalidLink: boolean;
    /**
     * If set, TypeDoc will produce warnings about \{\@link\} tags which do not link directly to their target.
     */
    rewrittenLink: boolean;
    /**
     * If set, TypeDoc will produce warnings about declarations that do not have doc comments
     */
    notDocumented: boolean;
    /**
     * If set, TypeDoc will produce warnings about `@mergeModuleWith` tags which were not resolved.
     */
    unusedMergeModuleWith: boolean;
};

type VarianceModifier

type VarianceModifier = (typeof VarianceModifier)[keyof typeof VarianceModifier];

Namespaces

namespace Configuration

module 'dist/lib/utils/options/index.d.ts' {}

variable CommentStyle

const CommentStyle: {
    readonly JSDoc: 'jsdoc';
    readonly Block: 'block';
    readonly Line: 'line';
    readonly All: 'all';
};

Determines how TypeDoc searches for comments.

variable EmitStrategy

const EmitStrategy: {
    readonly both: 'both';
    readonly docs: 'docs';
    readonly none: 'none';
};

function Option

Option: <K extends keyof TypeDocOptionMap>(
    name: K
) => (
    _: unknown,
    _context: ClassAccessorDecoratorContext<
        { application: Application } | { options: Options },
        TypeDocOptionValues[K]
    >
) => {
    get(
        this: { application: Application } | { options: Options }
    ): TypeDocOptionValues[K];
    set(_value: never): never;
};

Binds an option to an accessor. Does not register the option.
Note: This is a standard ES decorator. It will not work with pre-TS 5.0 experimental decorators enabled.

class ArgumentsReader

class ArgumentsReader implements OptionsReader {}

Obtains option values from command-line arguments

constructor

constructor(priority: number, args?: string[]);

property name

readonly name: string;

property order

readonly order: number;

property supportsPackages

readonly supportsPackages: boolean;

method ignoreErrors

ignoreErrors: () => this;

method read

read: (container: Options, logger: Logger) => void;

class Options

class Options {}

Maintains a collection of option declarations split into TypeDoc options and TypeScript options. Ensures options are of the correct type for calling code.
### Option Discovery
Since plugins commonly add custom options, and TypeDoc does not permit options which have not been declared to be set, options must be read twice. The first time options are read, a noop logger is passed so that any errors are ignored. Then, after loading plugins, options are read again, this time with the logger specified by the application.
Options are read in a specific order. 1. argv (0) - Must be read first since it should change the files read when passing --options or --tsconfig. 2. typedoc-json (100) - Read next so that it can specify the tsconfig.json file to read. 3. tsconfig-json (200) - Last config file reader, cannot specify the typedoc.json file to read. 4. argv (300) - Read argv again since any options set there should override those set in config files.
None Contains all of TypeDoc's option declarations & values

constructor

constructor();

property packageDir

packageDir?: string;

In packages mode, the directory of the package being converted.

method addDeclaration

addDeclaration: {
    <K extends keyof TypeDocOptionMap>(
        declaration: { name: K } & KeyToDeclaration<K>
    ): void;
    (declaration: NeverIfInternal<Readonly<DeclarationOption>>): void;
};

Adds an option declaration to the container with extra type checking to ensure that the runtime type is consistent with the declared type.
Parameter declaration
The option declaration that should be added.
Adds an option declaration to the container.
Parameter declaration
The option declaration that should be added.

method addReader

addReader: (reader: OptionsReader) => void;

Adds an option reader that will be used to read configuration values from the command line, configuration files, or other locations.
Parameter reader

method copyForPackage

copyForPackage: (packageDir: string) => Options;

Clones the options, intended for use in packages mode.

method getCompilerOptions

getCompilerOptions: (logger: Logger) => ts.CompilerOptions;

Gets the set compiler options.

method getDeclaration

getDeclaration: (name: string) => Readonly<DeclarationOption> | undefined;

Gets a declaration by one of its names.
Parameter name

method getDeclarations

getDeclarations: () => Readonly<DeclarationOption>[];

Gets all declared options.

method getFileNames

getFileNames: () => readonly string[];

Gets the file names discovered through reading a tsconfig file.

method getHelp

getHelp: () => string;

Get the help message to be displayed to the user if --help is passed.

method getProjectReferences

getProjectReferences: () => readonly ts.ProjectReference[];

Gets the project references - used in solution style tsconfig setups.

method getRawValues

getRawValues: () => Readonly<Partial<TypeDocOptionValues>>;

Gets all of the TypeDoc option values defined in this option container.

method getSimilarOptions

getSimilarOptions: (missingName: string) => string[];

Discover similar option names to the given name, for use in error reporting.

method getValue

getValue: {
    <K extends keyof TypeDocOptionMap>(name: K): TypeDocOptionValues[K];
    (name: NeverIfInternal<string>): unknown;
};

Gets a value for the given option key, throwing if the option has not been declared.
Parameter name

method isSet

isSet: {
    (name: keyof TypeDocOptions): boolean;
    (name: NeverIfInternal<string>): boolean;
};

Checks if the given option's value is deeply strict equal to the default.
Parameter name

method read

read: (
    logger: Logger,
    cwd?: string,
    usedFile?: (path: string) => void
) => Promise<void>;

method reset

reset: {
    (name?: keyof TypeDocOptions): void;
    (name?: NeverIfInternal<string>): void;
};

Resets the option bag to all default values. If a name is provided, will only reset that name.

method setCompilerOptions

setCompilerOptions: (
    fileNames: readonly string[],
    options: ts.CompilerOptions,
    projectReferences: readonly ts.ProjectReference[] | undefined
) => void;

Sets the compiler options that will be used to get a TS program.

method setValue

setValue: {
    <K extends keyof TypeDocOptionMap>(
        name: K,
        value: Exclude<TypeDocOptions[K], undefined>,
        configPath?: string
    ): void;
    (
        name: NeverIfInternal<string>,
        value: NeverIfInternal<unknown>,
        configPath?: NeverIfInternal<string>
    ): void;
};

Sets the given declared option. Throws if setting the option fails.
Parameter name
Parameter value
Parameter configPath
the directory to resolve Path type values against

class PackageJsonReader

class PackageJsonReader implements OptionsReader {}

property name

name: string;

property order

order: number;

property supportsPackages

supportsPackages: boolean;

method read

read: (
    container: Options,
    logger: Logger,
    cwd: string,
    usedFile: (path: string) => void
) => void;

class TSConfigReader

class TSConfigReader implements OptionsReader {}

property name

name: string;

property order

order: number;

Note: Runs after the TypeDocReader.

property supportsPackages

supportsPackages: boolean;

method read

read: (
    container: Options,
    logger: Logger,
    cwd: string,
    usedFile?: (path: string) => void
) => void;

class TypeDocReader

class TypeDocReader implements OptionsReader {}

Obtains option values from typedoc.json

property name

name: string;

property order

order: number;

Should run before the tsconfig reader so that it can specify a tsconfig file to read.

property supportsPackages

supportsPackages: boolean;

method read

read: (
    container: Options,
    logger: Logger,
    cwd: string,
    usedFile: (path: string) => void
) => Promise<void>;

Read user configuration from a typedoc.json or typedoc.js configuration file.

interface ArrayDeclarationOption

interface ArrayDeclarationOption extends DeclarationOptionBase {}

property defaultValue

defaultValue?: readonly string[];

If not specified defaults to an empty array.

property type

type:
    | ParameterType.Array
    | ParameterType.PathArray
    | ParameterType.ModuleArray
    | ParameterType.PluginArray;

property validate

validate?: (value: string[]) => void;

An optional validation function that validates a potential value of this option. The function must throw an Error if the validation fails and should do nothing otherwise.

interface BooleanDeclarationOption

interface BooleanDeclarationOption extends DeclarationOptionBase {}

property defaultValue

defaultValue?: boolean;

If not specified defaults to false.

property type

type: ParameterType.Boolean;

interface DeclarationOptionBase

interface DeclarationOptionBase {}

property configFileOnly

configFileOnly?: boolean;

If set, this option will be omitted from --help, and attempting to specify it on the command line will produce an error.

property help

help: NeverIfInternal<string> | (() => string);

The help text to be displayed to the user when --help is passed.
This may be a string, which will be presented directly, or a function, which will be called so that option help can be translated into the user specified locale.

property name

name: string;

The option name.

property type

type?: ParameterType;

The parameter type, used to convert user configuration values into the expected type. If not set, the type will be a string.

interface FlagsDeclarationOption

interface FlagsDeclarationOption<T extends Record<string, boolean>>
    extends DeclarationOptionBase {}

property defaults

defaults: T;

All of the possible flags, with their default values set.

property type

type: ParameterType.Flags;

interface GlobArrayDeclarationOption

interface GlobArrayDeclarationOption extends DeclarationOptionBase {}

property defaultValue

defaultValue?: readonly string[];

If not specified defaults to an empty array. If specified, globs are relative to cwd when TypeDoc is run.

property type

type: ParameterType.GlobArray;

property validate

validate?: (value: GlobString[]) => void;

An optional validation function that validates a potential value of this option. The function must throw an Error if the validation fails and should do nothing otherwise.

interface MapDeclarationOption

interface MapDeclarationOption<T> extends DeclarationOptionBase {}

property defaultValue

defaultValue: T;

Unlike the rest of the option types, there is no sensible generic default for mapped option types. The default value for a mapped type must be specified.

property map

map: Map<string, T> | Record<string | number, T>;

Maps a given value to the option type. The map type may be a TypeScript enum. In that case, when generating an error message for a mismatched key, the numeric keys will not be listed.

property type

type: ParameterType.Map;

interface MixedDeclarationOption

interface MixedDeclarationOption extends DeclarationOptionBase {}

property defaultValue

defaultValue?: unknown;

If not specified defaults to undefined.

property type

type: ParameterType.Mixed;

property validate

validate?: (value: unknown) => void;

An optional validation function that validates a potential value of this option. The function must throw an Error if the validation fails and should do nothing otherwise.

interface NumberDeclarationOption

interface NumberDeclarationOption extends DeclarationOptionBase {}

property defaultValue

defaultValue?: number;

If not specified defaults to 0.

property maxValue

maxValue?: number;

Highest possible value.

property minValue

minValue?: number;

Lowest possible value.

property type

type: ParameterType.Number;

property validate

validate?: (value: number) => void;

An optional validation function that validates a potential value of this option. The function must throw an Error if the validation fails and should do nothing otherwise.

interface ObjectDeclarationOption

interface ObjectDeclarationOption extends DeclarationOptionBase {}

property defaultValue

defaultValue?: unknown;

If not specified defaults to undefined.

property type

type: ParameterType.Object;

property validate

validate?: (value: unknown) => void;

An optional validation function that validates a potential value of this option. The function must throw an Error if the validation fails and should do nothing otherwise.

interface OptionsReader

interface OptionsReader {}

Describes an option reader that discovers user configuration and converts it to the TypeDoc format.

property name

readonly name: string;

The name of this reader so that it may be removed by plugins without the plugin accessing the instance performing the read. Multiple readers may have the same name.

property order

readonly order: number;

Readers will be processed according to their orders. A higher order indicates that the reader should be called *later*.
Note that to preserve expected behavior, the argv reader must have both the lowest order so that it may set the location of config files used by other readers and the highest order so that it can override settings from lower order readers.

property supportsPackages

readonly supportsPackages: boolean;

Flag to indicate that this reader should be included in sub-options objects created to read options for packages mode.

method read

read: (
    container: Options,
    logger: Logger,
    cwd: string,
    usedFile: (file: string) => void
) => void | Promise<void>;

Read options from the reader's source and place them in the options parameter. Options without a declared name may be treated as if they were declared with type ParameterType.Mixed. Options which have been declared must be converted to the correct type. As an alternative to doing this conversion in the reader, the reader may use Options.setValue, which will correctly convert values.
Parameter container
the options container that provides declarations
Parameter logger
logger to be used to report errors
Parameter cwd
the directory which should be treated as the current working directory for option file discovery
Parameter usedFile
a callback to track files that were read or whose existence was checked, for purposes of restarting a build when watching files

interface ParameterTypeToOptionTypeMap

interface ParameterTypeToOptionTypeMap {}

property [ParameterType.Array]

[ParameterType.Array]: string[];

property [ParameterType.Boolean]

[ParameterType.Boolean]: boolean;

property [ParameterType.Flags]

[ParameterType.Flags]: Record<string, boolean>;

property [ParameterType.GlobArray]

[ParameterType.GlobArray]: GlobString[];

property [ParameterType.Map]

[ParameterType.Map]: unknown;

property [ParameterType.Mixed]

[ParameterType.Mixed]: unknown;

property [ParameterType.ModuleArray]

[ParameterType.ModuleArray]: NormalizedPathOrModule[];

property [ParameterType.Number]

[ParameterType.Number]: number;

property [ParameterType.Object]

[ParameterType.Object]: unknown;

property [ParameterType.Path]

[ParameterType.Path]: NormalizedPath;

property [ParameterType.PathArray]

[ParameterType.PathArray]: NormalizedPath[];

property [ParameterType.PluginArray]

[ParameterType.PluginArray]: Array<
    NormalizedPathOrModule | ((app: Application) => void | Promise<void>)
>;

property [ParameterType.String]

[ParameterType.String]: string;

property [ParameterType.UrlOrPath]

[ParameterType.UrlOrPath]: NormalizedPath | string;

interface StringDeclarationOption

interface StringDeclarationOption extends DeclarationOptionBase {}

property defaultValue

defaultValue?: string;

If not specified defaults to the empty string for all types.

property hint

hint?: ParameterHint;

An optional hint for the type of input expected, will be displayed in the help output.

property outputShortcut

outputShortcut?: string;

If specified, when this output is specified TypeDoc will automatically add an output to the outputs option whose name is the value of this property with the path set to the value of this option. Should only be used with type set to ParameterType.Path.
If any output shortcuts are set, the outputs option will be ignored.

property type

type?: ParameterType.String | ParameterType.Path | ParameterType.UrlOrPath;

Specifies the resolution strategy. If Path is provided, values will be resolved according to their location in a file. If String or no value is provided, values will not be resolved.

property validate

validate?: (value: string) => void;

An optional validation function that validates a potential value of this option. The function must throw an Error if the validation fails and should do nothing otherwise.

interface TypeDocOptionMap

interface TypeDocOptionMap {}

Describes all TypeDoc options. Used internally to provide better types when fetching options. External consumers should likely use TypeDocOptions instead.
If writing a plugin, you may find it useful to use declaration merging to add your options to this interface so that you have autocomplete when using app.options.getValue.
declare module "typedoc" { export interface TypeDocOptionMap { pluginOption: string[]; } }

property alwaysCreateEntryPointModule

alwaysCreateEntryPointModule: boolean;

property basePath

basePath: NormalizedPath;

property blockTags

blockTags: TagString[];

property cacheBust

cacheBust: boolean;

property cascadedModifierTags

cascadedModifierTags: TagString[];

property categorizeByGroup

categorizeByGroup: boolean;

property categoryOrder

categoryOrder: string[];

property cleanOutputDir

cleanOutputDir: boolean;

property cname

cname: string;

property commentStyle

commentStyle: typeof CommentStyle;

property compilerOptions

compilerOptions: unknown;

property customCss

customCss: NormalizedPath;

property customFooterHtml

customFooterHtml: string;

property customFooterHtmlDisableWrapper

customFooterHtmlDisableWrapper: boolean;

property customJs

customJs: NormalizedPath;

property darkHighlightTheme

darkHighlightTheme: ShikiTheme;

property defaultCategory

defaultCategory: string;

property disableGit

disableGit: boolean;

property disableSources

disableSources: boolean;

property displayBasePath

displayBasePath: NormalizedPath;

property emit

emit: typeof EmitStrategy;

property entryPoints

entryPoints: GlobString[];

property entryPointStrategy

entryPointStrategy: typeof EntryPointStrategy;

property exclude

exclude: GlobString[];

property excludeCategories

excludeCategories: string[];

property excludeExternals

excludeExternals: boolean;

property excludeInternal

excludeInternal: boolean;

property excludeNotDocumented

excludeNotDocumented: boolean;

property excludeNotDocumentedKinds

excludeNotDocumentedKinds: ReflectionKind.KindString[];

property excludePrivate

excludePrivate: boolean;

property excludeProtected

excludeProtected: boolean;

property excludeReferences

excludeReferences: boolean;

property excludeTags

excludeTags: TagString[];

property externalPattern

externalPattern: GlobString[];

property externalSymbolLinkMappings

externalSymbolLinkMappings: ManuallyValidatedOption<
    Record<string, Record<string, string>>
>;

property favicon

favicon: NormalizedPath;

property githubPages

githubPages: boolean;

property gitRemote

gitRemote: string;

property gitRevision

gitRevision: string;

property groupOrder

groupOrder: string[];

property groupReferencesByType

groupReferencesByType: boolean;

property headings

headings: {
    readme: boolean;
    document: boolean;
};

property help

help: boolean;

property hideGenerator

hideGenerator: boolean;

property highlightLanguages

highlightLanguages: string[];

property hostedBaseUrl

hostedBaseUrl: string;

property html

html: NormalizedPath;

property ignoredHighlightLanguages

ignoredHighlightLanguages: string[];

property includeHierarchySummary

includeHierarchySummary: boolean;

property includeVersion

includeVersion: boolean;

property inlineTags

inlineTags: TagString[];

property intentionallyNotDocumented

intentionallyNotDocumented: string[];

property intentionallyNotExported

intentionallyNotExported: string[];

property jsDocCompatibility

jsDocCompatibility: JsDocCompatibility;

property json

json: NormalizedPath;

property kindSortOrder

kindSortOrder: ReflectionKind.KindString[];

property lang

lang: string;

property lightHighlightTheme

lightHighlightTheme: ShikiTheme;

property locales

locales: ManuallyValidatedOption<Record<string, Record<string, string>>>;

property logLevel

logLevel: typeof LogLevel;

property markdownItLoader

markdownItLoader: ManuallyValidatedOption<(parser: any) => void>;

Will be called when TypeDoc is setting up the markdown parser to use to render markdown. Can be used to add markdown-it plugins to the parser with code like this:

// typedoc.config.mjs
import iterator from "markdown-it-for-inline";
export default {
    /** @param {MarkdownIt} parser *\/
    markdownItLoader(parser) {
        parser.use(iterator, "foo_replace", "text", function(tokens, idx) {
            tokens[idx].content = tokens[idx].content.replace(/foo/g, 'bar');
        });
    }
}

Note: Unfortunately, markdown-it doesn't ship its own types, so parser isn't strictly typed here.

property markdownItOptions

markdownItOptions: ManuallyValidatedOption<Record<string, unknown>>;

property markdownLinkExternal

markdownLinkExternal: boolean;

property maxTypeConversionDepth

maxTypeConversionDepth: number;

property modifierTags

modifierTags: TagString[];

property name

name: string;

navigation: {
    includeCategories: boolean;
    includeGroups: boolean;
    includeFolders: boolean;
    compactFolders: boolean;
    excludeReferences: boolean;
};

property navigationLeaves

navigationLeaves: string[];

property navigationLinks

navigationLinks: ManuallyValidatedOption<Record<string, string>>;

property notRenderedTags

notRenderedTags: TagString[];

property options

options: NormalizedPath;

property out

out: NormalizedPath;

property outputs

outputs: ManuallyValidatedOption<Array<OutputSpecification>>;

property packageOptions

packageOptions: ManuallyValidatedOption<TypeDocPackageOptions>;

property packagesRequiringDocumentation

packagesRequiringDocumentation: string[];

property plugin

plugin: NormalizedPathOrModuleOrFunction[];

property preserveLinkText

preserveLinkText: boolean;

property preserveWatchOutput

preserveWatchOutput: boolean;

property pretty

pretty: boolean;

property projectDocuments

projectDocuments: GlobString[];

property readme

readme: string;

property requiredToBeDocumented

requiredToBeDocumented: ReflectionKind.KindString[];

property router

router: string;

property searchCategoryBoosts

searchCategoryBoosts: ManuallyValidatedOption<Record<string, number>>;

property searchGroupBoosts

searchGroupBoosts: ManuallyValidatedOption<Record<string, number>>;

property searchInComments

searchInComments: boolean;

property searchInDocuments

searchInDocuments: boolean;

property showConfig

showConfig: boolean;

property sidebarLinks

sidebarLinks: ManuallyValidatedOption<Record<string, string>>;

property skipErrorChecking

skipErrorChecking: boolean;

property sluggerConfiguration

sluggerConfiguration: {
    lowercase: boolean;
};

property sort

sort: SortStrategy[];

property sortEntryPoints

sortEntryPoints: boolean;

property sourceLinkExternal

sourceLinkExternal: boolean;

property sourceLinkTemplate

sourceLinkTemplate: string;

property suppressCommentWarningsInDeclarationFiles

suppressCommentWarningsInDeclarationFiles: boolean;

property theme

theme: string;

property titleLink

titleLink: string;

property treatValidationWarningsAsErrors

treatValidationWarningsAsErrors: boolean;

property treatWarningsAsErrors

treatWarningsAsErrors: boolean;

property tsconfig

tsconfig: NormalizedPath;

property typePrintWidth

typePrintWidth: number;

property useFirstParagraphOfCommentAsSummary

useFirstParagraphOfCommentAsSummary: boolean;

property useHostedBaseUrlForAbsoluteLinks

useHostedBaseUrlForAbsoluteLinks: boolean;

property useTsLinkResolution

useTsLinkResolution: boolean;

property validation

validation: ValidationOptions;

property version

version: boolean;

property visibilityFilters

visibilityFilters: ManuallyValidatedOption<{
    protected?: boolean;
    private?: boolean;
    inherited?: boolean;
    external?: boolean;
    [tag: TagString]: boolean;
}>;

property watch

watch: boolean;

interface TypeDocPackageOptions

interface TypeDocPackageOptions
    extends Omit<TypeDocOptions, (typeof rootPackageOptions)[number]> {}

Describes TypeDoc options suitable for setting within the packageOptions setting.
This is a subset of all options specified in TypeDocOptions.

enum ParameterHint

enum ParameterHint {
    File = 0,
    Directory = 1,
}

member Directory

Directory = 1

member File

File = 0

enum ParameterType

enum ParameterType {
    String = 0,
    Path = 1,
    UrlOrPath = 2,
    Number = 3,
    Boolean = 4,
    Map = 5,
    Mixed = 6,
    Array = 7,
    PathArray = 8,
    ModuleArray = 9,
    GlobArray = 11,
    Object = 12,
    Flags = 13,
}

member Array

Array = 7

member Boolean

Boolean = 4

member Flags

Flags = 13

An object with true/false flags

member GlobArray

GlobArray = 11

Relative to the config directory.

member Map

Map = 5

member Mixed

Mixed = 6

member ModuleArray

ModuleArray = 9

Resolved according to the config directory if it starts with .
Deprecated
since 0.28.8, will be removed in 0.29

member Number

Number = 3

member Object

Object = 12

An object which partially merges user-set values into the defaults.

member Path

Path = 1

Resolved according to the config directory.

member PathArray

PathArray = 8

Resolved according to the config directory.

member String

String = 0

member UrlOrPath

UrlOrPath = 2

Resolved according to the config directory unless it starts with https?://

type CommentStyle

type CommentStyle = (typeof CommentStyle)[keyof typeof CommentStyle];

type DeclarationOption

type DeclarationOption =
    | StringDeclarationOption
    | NumberDeclarationOption
    | BooleanDeclarationOption
    | MixedDeclarationOption
    | ObjectDeclarationOption
    | MapDeclarationOption<unknown>
    | ArrayDeclarationOption
    | GlobArrayDeclarationOption
    | FlagsDeclarationOption<Record<string, boolean>>;

type DeclarationOptionToOptionType

type DeclarationOptionToOptionType<T extends DeclarationOption> =
    T extends MapDeclarationOption<infer U>
        ? U
        : T extends FlagsDeclarationOption<infer U>
        ? U
        : ParameterTypeToOptionTypeMap[Exclude<T['type'], undefined>];

type EmitStrategy

type EmitStrategy = (typeof EmitStrategy)[keyof typeof EmitStrategy];

type JsDocCompatibility

type JsDocCompatibility = {
    /**
     * If set, TypeDoc will treat `@example` blocks as code unless they contain a code block.
     * On by default, this is how VSCode renders blocks.
     */
    exampleTag: boolean;
    /**
     * If set, TypeDoc will treat `@default` blocks as code unless they contain a code block.
     * On by default, this is how VSCode renders blocks.
     */
    defaultTag: boolean;
    /**
     * If set, TypeDoc will warn if a `@inheritDoc` tag is spelled without TSDoc capitalization
     * (i.e. `@inheritdoc`). On by default.
     */
    inheritDocTag: boolean;
    /**
     * If set, TypeDoc will not emit warnings about unescaped `{` and `}` characters encountered
     * when parsing a comment. On by default.
     */
    ignoreUnescapedBraces: boolean;
};

type KeyToDeclaration

type KeyToDeclaration<K extends keyof TypeDocOptionMap> =
    TypeDocOptionMap[K] extends boolean
        ? BooleanDeclarationOption
        : TypeDocOptionMap[K] extends string | NormalizedPath
        ? StringDeclarationOption
        : TypeDocOptionMap[K] extends number
        ? NumberDeclarationOption
        : TypeDocOptionMap[K] extends GlobString[]
        ? GlobArrayDeclarationOption
        : TypeDocOptionMap[K] extends
              | string[]
              | NormalizedPath[]
              | NormalizedPathOrModule[]
              | NormalizedPathOrModuleOrFunction[]
        ? ArrayDeclarationOption
        : unknown extends TypeDocOptionMap[K]
        ? MixedDeclarationOption | ObjectDeclarationOption
        : TypeDocOptionMap[K] extends ManuallyValidatedOption<unknown>
        ?
              | (MixedDeclarationOption & {
                    validate(value: unknown, i18n: TranslationProxy): void;
                })
              | (ObjectDeclarationOption & {
                    validate(value: unknown, i18n: TranslationProxy): void;
                })
        : TypeDocOptionMap[K] extends Record<string, boolean>
        ? FlagsDeclarationOption<TypeDocOptionMap[K]>
        : TypeDocOptionMap[K] extends Record<string | number, infer U>
        ? MapDeclarationOption<U>
        : never;

Converts a given TypeDoc option key to the type of the declaration expected.

type ManuallyValidatedOption

type ManuallyValidatedOption<T> = {
    __validated: T;
};

Wrapper type for values in TypeDocOptionMap which are represented with an unknown option type, but have a validation function that checks that they are the given type.

type OutputSpecification

type OutputSpecification = {
    name: string;
    path: string;
    options?: TypeDocOptions;
};

type TypeDocOptions

type TypeDocOptions = {
    [K in keyof TypeDocOptionMap]?: unknown extends TypeDocOptionMap[K]
        ? unknown
        : TypeDocOptionMap[K] extends ManuallyValidatedOption<
              infer ManuallyValidated
          >
        ? ManuallyValidated
        : TypeDocOptionMap[K] extends
              | NormalizedPath[]
              | NormalizedPathOrModule[]
              | NormalizedPathOrModuleOrFunction[]
              | GlobString[]
        ? string[]
        : TypeDocOptionMap[K] extends NormalizedPath
        ? string
        : TypeDocOptionMap[K] extends string | string[] | number | boolean
        ? TypeDocOptionMap[K]
        : TypeDocOptionMap[K] extends Record<string, boolean>
        ? Partial<TypeDocOptionMap[K]> | boolean
        : keyof TypeDocOptionMap[K] | TypeDocOptionMap[K][keyof TypeDocOptionMap[K]];
};

An interface describing all TypeDoc specific options. Generated from a map which contains more information about each option for better types when defining said options.

type TypeDocOptionValues

type TypeDocOptionValues = {
    [K in keyof TypeDocOptionMap]: unknown extends TypeDocOptionMap[K]
        ? unknown
        : TypeDocOptionMap[K] extends ManuallyValidatedOption<
              infer ManuallyValidated
          >
        ? ManuallyValidated
        : TypeDocOptionMap[K] extends
              | string
              | string[]
              | GlobString[]
              | NormalizedPathOrModule[]
              | NormalizedPathOrModuleOrFunction[]
              | number
              | boolean
              | Record<string, boolean>
        ? TypeDocOptionMap[K]
        : TypeDocOptionMap[K][keyof TypeDocOptionMap[K]];
};

Describes all TypeDoc specific options as returned by Options.getValue, this is slightly more restrictive than the TypeDocOptions since it does not allow both keys and values for mapped option types, and does not allow partials of flag values. It also does not mark keys as optional.

type ValidationOptions

type ValidationOptions = {
    /**
     * If set, TypeDoc will produce warnings when a symbol is referenced by the documentation,
     * but is not included in the documentation.
     */
    notExported: boolean;
    /**
     * If set, TypeDoc will produce warnings about \{\@link\} tags which will produce broken links.
     */
    invalidLink: boolean;
    /**
     * If set, TypeDoc will produce warnings about \{\@link\} tags which do not link directly to their target.
     */
    rewrittenLink: boolean;
    /**
     * If set, TypeDoc will produce warnings about declarations that do not have doc comments
     */
    notDocumented: boolean;
    /**
     * If set, TypeDoc will produce warnings about `@mergeModuleWith` tags which were not resolved.
     */
    unusedMergeModuleWith: boolean;
};

namespace OptionDefaults

module 'dist/lib/utils/options/defaults.d.ts' {}

Defaults values for TypeDoc options

variable blockTags

const blockTags: readonly TagString[];

variable cascadedModifierTags

const cascadedModifierTags: readonly TagString[];

variable excludeNotDocumentedKinds

const excludeNotDocumentedKinds: readonly EnumKeys<typeof ReflectionKind>[];

variable excludeTags

const excludeTags: readonly TagString[];

variable highlightLanguages

const highlightLanguages: readonly BundledLanguage[];

variable ignoredHighlightLanguages

const ignoredHighlightLanguages: readonly string[];

variable inlineTags

const inlineTags: readonly TagString[];

variable kindSortOrder

const kindSortOrder: readonly EnumKeys<typeof ReflectionKind>[];

variable modifierTags

const modifierTags: readonly TagString[];

variable notRenderedTags

const notRenderedTags: readonly TagString[];

variable requiredToBeDocumented

const requiredToBeDocumented: readonly EnumKeys<typeof ReflectionKind>[];

variable sort

const sort: readonly string[];

namespace Internationalization

module 'dist/lib/internationalization/index.d.ts' {}

Internationalization module for localized strings in output. Internationalization module for localized strings in output.

class Internationalization

class Internationalization {}

Responsible for maintaining loaded internationalized strings.

constructor

constructor();

method addTranslations

addTranslations: (locale: string, translations: Record<string, string>) => void;

method getSupportedLanguages

getSupportedLanguages: () => string[];

method hasTranslations

hasTranslations: (locale: string) => boolean;

method setLocale

setLocale: (locale: string) => void;

interface TranslatableStrings

interface TranslatableStrings extends BuiltinTranslatableStringArgs {}

### 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 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 1
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]; } }

type TranslationProxy

type TranslationProxy = {
    [K in keyof TranslatableStrings]: (
        ...args: TranslatableStrings[K]
    ) => TranslatedString;
};

Dynamic proxy type built from TranslatableStrings

namespace JSONOutput

module 'dist/lib/serialization/schema.d.ts' {}

Contains interfaces which describe the JSON output. Each interface is related to a specific type of serializer.
## Plugins Plugins which modify the serialization process can use declaration merging to add custom properties to the exported interfaces. For example, if your custom serializer adds a property to all Reflection objects:
declare module 'typedoc/dist/lib/serialization/schema' { export interface AbstractReflection { myCustomProp: boolean } }
If a plugin defines a new Model type, ModelToObject will not pick up the serializer type and the resulting type will not be included in the return type of Serializer.toObject. To fix this, use declaration merging to augment the Serializer class.
declare module 'typedoc/dist/lib/serialization/serializer' { export interface Serializer { toObject(value: CustomModel, obj?: Partial<CustomModel>): CustomOutput } }
For documentation on the JSON output properties, view the corresponding model. Contains interfaces which describe the JSON output.

variable SCHEMA_VERSION

const SCHEMA_VERSION: string;

interface ArrayType

interface ArrayType extends Type, S<M.ArrayType, 'type' | 'elementType'> {}

Types

interface Comment

interface Comment extends Partial<S<M.Comment, 'blockTags' | 'label'>> {}

Comments

property modifierTags

modifierTags?: TagString[];

property summary

summary: CommentDisplayPart[];

interface CommentTag

interface CommentTag extends S<M.CommentTag, 'tag' | 'name'> {}

Comments

property content

content: CommentDisplayPart[];

interface ConditionalType

interface ConditionalType
    extends Type,
        S<
            M.ConditionalType,
            'type' | 'checkType' | 'extendsType' | 'trueType' | 'falseType'
        > {}

Types

interface ContainerReflection

interface ContainerReflection
    extends Reflection,
        S<
            M.ContainerReflection,
            'children' | 'documents' | 'groups' | 'categories'
        > {}

Reflections

property childrenIncludingDocuments

childrenIncludingDocuments?: ReflectionId[];

interface DeclarationReflection

interface DeclarationReflection
    extends Omit<ContainerReflection, 'variant'>,
        S<
            M.DeclarationReflection,
            | 'variant'
            | 'packageVersion'
            | 'sources'
            | 'type'
            | 'signatures'
            | 'indexSignatures'
            | 'defaultValue'
            | 'overwrites'
            | 'inheritedFrom'
            | 'implementationOf'
            | 'extendedTypes'
            | 'extendedBy'
            | 'implementedTypes'
            | 'implementedBy'
            | 'getSignature'
            | 'setSignature'
            | 'typeParameters'
            | 'readme'
        > {}

Reflections

interface DocumentReflection

interface DocumentReflection
    extends Omit<Reflection, 'variant'>,
        S<
            M.DocumentReflection,
            'variant' | 'content' | 'relevanceBoost' | 'children'
        > {}

Reflections

property frontmatter

frontmatter: Record<string, unknown>;

interface FileRegistry

interface FileRegistry {}

property entries

entries: Record<FileId, NormalizedPath>;

Relative path according to the serialization root

property reflections

reflections: Record<FileId, ReflectionId>;

File ID to reflection ID

interface IndexedAccessType

interface IndexedAccessType
    extends Type,
        S<M.IndexedAccessType, 'type' | 'indexType' | 'objectType'> {}

Types

interface InferredType

interface InferredType
    extends Type,
        S<M.InferredType, 'type' | 'name' | 'constraint'> {}

Types

interface InlineTagDisplayPart

interface InlineTagDisplayPart {}

If target is a number, it is a reflection ID. If a string, it is a URL. target will only be set for @link, @linkcode, and @linkplain tags. Comments

property kind

kind: 'inline-tag';

property tag

tag: TagString;

property target

target?: string | ReflectionId | ReflectionSymbolId;

property text

text: string;

property tsLinkText

tsLinkText?: string;

interface IntersectionType

interface IntersectionType extends Type, S<M.IntersectionType, 'type' | 'types'> {}

Types

interface IntrinsicType

interface IntrinsicType extends Type, S<M.IntrinsicType, 'type' | 'name'> {}

Types

interface LiteralType

interface LiteralType extends Type, S<M.LiteralType, 'type' | 'value'> {}

Types

interface MappedType

interface MappedType
    extends Type,
        S<
            M.MappedType,
            | 'type'
            | 'parameter'
            | 'parameterType'
            | 'templateType'
            | 'readonlyModifier'
            | 'optionalModifier'
            | 'nameType'
        > {}

Types

interface NamedTupleMemberType

interface NamedTupleMemberType
    extends Type,
        S<M.NamedTupleMember, 'type' | 'name' | 'isOptional' | 'element'> {}

Types

interface OptionalType

interface OptionalType extends Type, S<M.OptionalType, 'type' | 'elementType'> {}

Types

interface ParameterReflection

interface ParameterReflection
    extends Omit<Reflection, 'variant'>,
        S<M.ParameterReflection, 'variant' | 'type' | 'defaultValue'> {}

Reflections

property variant

variant: 'param';

interface PredicateType

interface PredicateType
    extends Type,
        S<M.PredicateType, 'type' | 'name' | 'asserts' | 'targetType'> {}

Types

interface ProjectReflection

interface ProjectReflection
    extends Omit<ContainerReflection, 'variant'>,
        S<
            M.ProjectReflection,
            'variant' | 'packageName' | 'packageVersion' | 'readme'
        > {}

Reflections

property files

files: FileRegistry;

property schemaVersion

schemaVersion: string;

Used to determine if TypeDoc supports deserializing the specified json See SCHEMA_VERSION for the current version.

property symbolIdMap

symbolIdMap:
    | Record<ReflectionId, ReflectionSymbolId>
    | IfInternal<undefined, never>;

interface QueryType

interface QueryType extends Type, S<M.QueryType, 'type' | 'queryType'> {}

Types

interface ReferenceReflection

interface ReferenceReflection
    extends Omit<DeclarationReflection, 'variant'>,
        S<M.ReferenceReflection, 'variant'> {}

Reflections

property target

target: ReflectionId;

-1 if the reference refers to a symbol that does not exist in the documentation. Otherwise, the reflection ID.

interface ReferenceType

interface ReferenceType
    extends Type,
        S<
            M.ReferenceType,
            'type' | 'name' | 'typeArguments' | 'package' | 'externalUrl'
        > {}

Types

property highlightedProperties

highlightedProperties?: Record<string, CommentDisplayPart[]>;

property preferValues

preferValues?: boolean;

property qualifiedName

qualifiedName?: string;

property refersToTypeParameter

refersToTypeParameter?: boolean;

property target

target: ReflectionId | ReflectionSymbolId;

interface Reflection

interface Reflection
    extends S<M.Reflection, 'id' | 'variant' | 'name' | 'kind' | 'comment'> {}

Reflections

property flags

flags: ReflectionFlags;

interface ReflectionCategory

interface ReflectionCategory
    extends S<M.ReflectionCategory, 'title' | 'description'> {}

property children

children?: M.ReflectionCategory['children'][number]['id'][];

interface ReflectionFlags

interface ReflectionFlags
    extends Partial<S<M.ReflectionFlags, BoolKeys<M.ReflectionFlags>>> {}

interface ReflectionGroup

interface ReflectionGroup
    extends S<M.ReflectionGroup, 'title' | 'description' | 'categories'> {}

property children

children?: M.ReflectionGroup['children'][number]['id'][];

interface ReflectionSymbolId

interface ReflectionSymbolId {}

property packageName

packageName: string;

property packagePath

packagePath: NormalizedPath;

property qualifiedName

qualifiedName: string;

interface ReflectionType

interface ReflectionType extends Type, S<M.ReflectionType, 'type' | 'declaration'> {}

Types

interface ReflectionVariantMap

interface ReflectionVariantMap {}

Reflections

property declaration

declaration: DeclarationReflection;

property document

document: DocumentReflection;

property param

param: ParameterReflection;

property project

project: ProjectReflection;

property reference

reference: ReferenceReflection;

property signature

signature: SignatureReflection;

property typeParam

typeParam: TypeParameterReflection;

interface RelativeLinkDisplayPart

interface RelativeLinkDisplayPart {}

This is used for relative links within comments/documents. It is used to mark pieces of text which need to be replaced to make links work properly.

property kind

kind: 'relative-link';

property target

target?: FileId;

File ID, if present

property targetAnchor

targetAnchor?: string;

Anchor within the target file, if present

property text

text: string;

The original relative text from the parsed comment.

interface RestType

interface RestType extends Type, S<M.RestType, 'type' | 'elementType'> {}

Types

interface SignatureReflection

interface SignatureReflection
    extends Omit<Reflection, 'variant'>,
        S<
            M.SignatureReflection,
            | 'variant'
            | 'sources'
            | 'parameters'
            | 'typeParameters'
            | 'type'
            | 'overwrites'
            | 'inheritedFrom'
            | 'implementationOf'
        > {}

Reflections

interface SourceReference

interface SourceReference
    extends S<M.SourceReference, 'fileName' | 'line' | 'character' | 'url'> {}

interface TemplateLiteralType

interface TemplateLiteralType
    extends Type,
        S<M.TemplateLiteralType, 'type' | 'head'> {}

Types

property tail

tail: [SomeType, string][];

interface TupleType

interface TupleType extends Type, S<M.TupleType, 'type'> {}

Types

property elements

elements?: ModelToObject<M.TupleType['elements']>;

interface Type

interface Type {}

Types

interface TypeOperatorType

interface TypeOperatorType
    extends Type,
        S<M.TypeOperatorType, 'type' | 'operator' | 'target'> {}

Types

interface TypeParameterReflection

interface TypeParameterReflection
    extends Omit<Reflection, 'variant'>,
        S<
            M.TypeParameterReflection,
            'variant' | 'type' | 'default' | 'varianceModifier'
        > {}

Reflections

interface UnionType

interface UnionType
    extends Type,
        S<M.UnionType, 'type' | 'types' | 'elementSummaries'> {}

Types

interface UnknownType

interface UnknownType extends Type, S<M.UnknownType, 'type' | 'name'> {}

Types

type CommentDisplayPart

type CommentDisplayPart =
    | {
          kind: 'text';
          text: string;
      }
    | {
          kind: 'code';
          text: string;
      }
    | InlineTagDisplayPart
    | RelativeLinkDisplayPart;

See Also
- M.CommentDisplayPart Comments

type FileId

type FileId = M.FileId;

type ModelToObject

type ModelToObject<T> = [T] extends [Array<infer U>]
    ? ModelToObject<U>[]
    : [M.SomeType] extends [T]
    ? SomeType
    : _ModelToObject<T>;

Describes the mapping from Model types to the corresponding JSON output type.

type ReflectionId

type ReflectionId = M.ReflectionId;

type SomeReflection

type SomeReflection = ReflectionVariantMap[keyof ReflectionVariantMap];

Reflections

type SomeType

type SomeType = TypeKindMap[keyof TypeKindMap];

Types

type TypeKindMap

type TypeKindMap = {
    array: ArrayType;
    conditional: ConditionalType;
    indexedAccess: IndexedAccessType;
    inferred: InferredType;
    intersection: IntersectionType;
    intrinsic: IntrinsicType;
    literal: LiteralType;
    mapped: MappedType;
    optional: OptionalType;
    predicate: PredicateType;
    query: QueryType;
    reference: ReferenceType;
    reflection: ReflectionType;
    rest: RestType;
    templateLiteral: TemplateLiteralType;
    tuple: TupleType;
    namedTupleMember: NamedTupleMemberType;
    typeOperator: TypeOperatorType;
    union: UnionType;
    unknown: UnknownType;
};

Types

namespace Models

module 'dist/lib/models/index.d.ts' {}

variable TypeContext

const TypeContext: {
    readonly none: 'none';
    readonly templateLiteralElement: 'templateLiteralElement';
    readonly arrayElement: 'arrayElement';
    readonly indexedAccessElement: 'indexedAccessElement';
    readonly conditionalCheck: 'conditionalCheck';
    readonly conditionalExtends: 'conditionalExtends';
    readonly conditionalTrue: 'conditionalTrue';
    readonly conditionalFalse: 'conditionalFalse';
    readonly indexedIndex: 'indexedIndex';
    readonly indexedObject: 'indexedObject';
    readonly inferredConstraint: 'inferredConstraint';
    readonly intersectionElement: 'intersectionElement';
    readonly mappedName: 'mappedName';
    readonly mappedParameter: 'mappedParameter';
    readonly mappedTemplate: 'mappedTemplate';
    readonly optionalElement: 'optionalElement';
    readonly predicateTarget: 'predicateTarget';
    readonly queryTypeTarget: 'queryTypeTarget';
    readonly typeOperatorTarget: 'typeOperatorTarget';
    readonly referenceTypeArgument: 'referenceTypeArgument';
    readonly restElement: 'restElement';
    readonly tupleElement: 'tupleElement';
    readonly unionElement: 'unionElement';
};

Enumeration that can be used when traversing types to track the location of recursion. Used by TypeDoc internally to track when to output parenthesis when rendering.

variable VarianceModifier

const VarianceModifier: {
    readonly in: 'in';
    readonly out: 'out';
    readonly inOut: 'in out';
};

Modifier flags for type parameters, added in TS 4.7

function makeRecursiveVisitor

makeRecursiveVisitor: (visitor: Partial<TypeVisitor>) => TypeVisitor;

function resetReflectionID

resetReflectionID: () => void;

Reset the reflection id.
Used by the test cases to ensure the reflection ids won't change between runs.

function splitUnquotedString

splitUnquotedString: (input: string, delimiter: string) => string[];

class ArrayType

class ArrayType extends Type {}

Represents an array type.
let value: string[];
Types

constructor

constructor(elementType: SomeType);

Parameter elementType
The type of the elements in the array.

property elementType

elementType: SomeType;

property type

readonly type: string;

method getTypeString

protected getTypeString: () => string;

method needsParenthesis

needsParenthesis: () => boolean;

method toObject

toObject: (serializer: Serializer) => JSONOutput.ArrayType;

class Comment

class Comment {}

A model that represents a comment.
Instances of this model are created by the CommentPlugin. You can retrieve comments through the DeclarationReflection.comment property. Comments

constructor

constructor(
    summary?: CommentDisplayPart[],
    blockTags?: CommentTag[],
    modifierTags?: Set<TagString>
);

Creates a new Comment instance.

property blockTags

blockTags: CommentTag[];

All associated block level tags.

property inheritedFromParentDeclaration

inheritedFromParentDeclaration?: boolean;

If the comment was inherited from a different "parent" declaration (see #2545), then it is desirable to know this as any @param tags which do not apply should not cause warnings. This is not serialized, and only set when the comment was created from a ts.CommentRange.

property label

label?: string;

Label associated with this reflection, if any (https://tsdoc.org/pages/tags/label/)

property modifierTags

modifierTags: Set<TagString>;

All modifier tags present on the comment, e.g. @alpha, @beta.

property sourcePath

sourcePath?: NormalizedPath;

Full path to the file where this comment originated from, if any. This field will not be serialized, so will not be present when handling JSON-revived reflections.
Note: This field is non-enumerable to make testing comment contents with deepEqual easier.

property summary

summary: CommentDisplayPart[];

The content of the comment which is not associated with a block tag.

method clone

clone: () => Comment;

Create a deep clone of this comment.

method cloneDisplayParts

static cloneDisplayParts: (
    parts: readonly CommentDisplayPart[]
) => CommentDisplayPart[];

Helper utility to clone Comment.summary or CommentTag.content

method combineDisplayParts

static combineDisplayParts: (
    parts: readonly CommentDisplayPart[] | undefined
) => string;

Debugging utility for combining parts into a simple string. Not suitable for rendering, but can be useful in tests.

method deserializeDisplayParts

static deserializeDisplayParts: (
    de: Deserializer,
    parts: JSONOutput.CommentDisplayPart[]
) => CommentDisplayPart[];

method fromObject

fromObject: (de: Deserializer, obj: JSONOutput.Comment) => void;

method getIdentifiedTag

getIdentifiedTag: (
    identifier: string,
    tagName: TagString
) => CommentTag | undefined;

method getShortSummary

getShortSummary: (useFirstParagraph: boolean) => readonly CommentDisplayPart[];

Gets either the @summary tag, or a short version of the comment summary section for rendering in module/namespace pages.

method getTag

getTag: (tagName: TagString) => CommentTag | undefined;

Return the first tag with the given name.
Parameter tagName
The name of the tag to look for.
Returns
The found tag or undefined.

method getTags

getTags: (tagName: TagString) => CommentTag[];

Get all tags with the given tag name.

method hasModifier

hasModifier: (tagName: TagString) => boolean;

Test whether this comment contains a tag with the given name.
Parameter tagName
The name of the tag to look for.
Returns
TRUE when this comment contains a tag with the given name, otherwise FALSE.

method hasVisibleComponent

hasVisibleComponent: (notRenderedTags?: readonly TagString[]) => boolean;

Checks if this comment contains any visible text.
Returns
TRUE when this reflection has a visible comment.

method removeModifier

removeModifier: (tagName: TagString) => void;

method removeTags

removeTags: (tagName: TagString) => void;

Removes all block tags with the given tag name from the comment.
Parameter tagName

method serializeDisplayParts

static serializeDisplayParts: {
    (parts: CommentDisplayPart[]): JSONOutput.CommentDisplayPart[];
    (parts: CommentDisplayPart[]): JSONOutput.CommentDisplayPart[];
};

no point in showing this signature in api docs

method similarTo

similarTo: (other: Comment) => boolean;

Checks if this comment is roughly equal to the other comment. This isn't exactly equal, but just "roughly equal" by the comment text.

method splitPartsToHeaderAndBody

static splitPartsToHeaderAndBody: (parts: readonly CommentDisplayPart[]) => {
    header: string;
    body: CommentDisplayPart[];
};

Splits the provided parts into a header (first line, as a string) and body (remaining lines). If the header line contains inline tags they will be serialized to a string.

method toObject

toObject: (serializer: Serializer) => JSONOutput.Comment;

class CommentTag

class CommentTag {}

A model that represents a single TypeDoc comment tag.
Tags are stored in the Comment.blockTags property. Comments

constructor

constructor(tag: TagString, text: CommentDisplayPart[]);

Create a new CommentTag instance.

property content

content: CommentDisplayPart[];

The actual body text of this tag.

property name

name?: string;

Some tags, (@typedef, @param, @property, etc.) may have a user defined identifier associated with them. If this tag is one of those, it will be parsed out and included here.

property skipRendering

skipRendering: boolean;

A flag which may be set by plugins to prevent TypeDoc from rendering this tag, if the plugin provides custom rendering. Note: This flag is **not** serialized, it is expected to be set just before the comment is rendered.

property tag

tag: TagString;

The name of this tag, e.g. @returns, @example

method clone

clone: () => CommentTag;

method fromObject

fromObject: (de: Deserializer, obj: JSONOutput.CommentTag) => void;

method similarTo

similarTo: (other: CommentTag) => boolean;

Checks if this block tag is roughly equal to the other tag. This isn't exactly equal, but just "roughly equal" by the tag text.

method toObject

toObject: () => JSONOutput.CommentTag;

class ConditionalType

class ConditionalType extends Type {}

Represents a conditional type.

let value: Check extends Extends ? True : False;

Types

constructor

constructor(
    checkType: SomeType,
    extendsType: SomeType,
    trueType: SomeType,
    falseType: SomeType
);

property checkType

checkType: SomeType;

property extendsType

extendsType: SomeType;

property falseType

falseType: SomeType;

property trueType

trueType: SomeType;

property type

readonly type: string;

method getTypeString

protected getTypeString: () => string;

method needsParenthesis

needsParenthesis: (context: TypeContext) => boolean;

method toObject

toObject: (serializer: Serializer) => JSONOutput.ConditionalType;

class ContainerReflection

abstract class ContainerReflection extends Reflection {}

Reflections

property categories

categories?: ReflectionCategory[];

All children grouped by their category.

property children

children?: DeclarationReflection[];

The children of this reflection. Do not add reflections to this array manually. Instead call addChild.

property childrenIncludingDocuments

childrenIncludingDocuments?: (DeclarationReflection | DocumentReflection)[];

Union of the children and documents arrays which dictates the sort order for rendering.

property documents

documents?: DocumentReflection[];

Documents associated with this reflection.
These are not children as including them as children requires code handle both types, despite being mostly unrelated and handled separately.
Including them here in a separate array neatly handles that problem, but also introduces another one for rendering. When rendering, documents should really actually be considered part of the "children" of a reflection. For this reason, we also maintain a list of child declarations with child documents which is used when rendering.

property groups

groups?: ReflectionGroup[];

All children grouped by their kind.

method addChild

addChild: (child: Reflection) => void;

method fromObject

fromObject: (de: Deserializer, obj: JSONOutput.ContainerReflection) => void;

method getChildrenByKind

getChildrenByKind: (kind: ReflectionKind) => DeclarationReflection[];

Return a list of all children of a certain kind.
Parameter kind
The desired kind of children.
Returns
An array containing all children with the desired kind.

method isContainer

isContainer: () => this is ContainerReflection;

method removeChild

removeChild: (child: DeclarationReflection | DocumentReflection) => void;

method toObject

toObject: (serializer: Serializer) => JSONOutput.ContainerReflection;

method traverse

traverse: (callback: TraverseCallback) => void;

class DeclarationReflection

class DeclarationReflection extends ContainerReflection {}

A reflection that represents a single declaration emitted by the TypeScript compiler.
All parts of a project are represented by DeclarationReflection instances. The actual kind of a reflection is stored in its kind member. Reflections

property defaultValue

defaultValue?: string;

The default value of this reflection.
Applies to function parameters, variables, and properties.

property extendedBy

extendedBy?: ReferenceType[];

A list of all types that extend this reflection (e.g. the subclasses).

property extendedTypes

extendedTypes?: SomeType[];

A list of all types this reflection extends (e.g. the parent classes).

property getSignature

getSignature?: SignatureReflection;

The get signature of this declaration.

property implementationOf

implementationOf?: ReferenceType;

A type that points to the reflection this reflection is the implementation of.
Applies to class members.

property implementedBy

implementedBy?: ReferenceType[];

A list of all types that implement this reflection.

property implementedTypes

implementedTypes?: SomeType[];

A list of all types this reflection implements.

property indexSignatures

indexSignatures?: SignatureReflection[];

The index signature of this declaration.

property inheritedFrom

inheritedFrom?: ReferenceType;

A type that points to the reflection this reflection has been inherited from.
Applies to interface and class members.

property overwrites

overwrites?: ReferenceType;

A type that points to the reflection that has been overwritten by this reflection.
Applies to interface and class members.

property packageVersion

packageVersion?: string;

The version of the module when found.

property readme

readme?: CommentDisplayPart[];

The contents of the readme file of the module when found.

property setSignature

setSignature?: SignatureReflection;

The set signature of this declaration.

property signatures

signatures?: SignatureReflection[];

A list of call signatures attached to this declaration.
TypeDoc creates one declaration per function that may contain one or more signature reflections.

property sources

sources?: SourceReference[];

A list of all source files that contributed to this reflection.

property type

type?: SomeType;

The type of the reflection.
If the reflection represents a variable or a property, this is the value type. If the reflection represents a signature, this is the return type.

property typeHierarchy

typeHierarchy?: DeclarationHierarchy;

Contains a simplified representation of the type hierarchy suitable for being rendered in templates.

property typeParameters

typeParameters?: TypeParameterReflection[];

property variant

readonly variant: 'reference' | 'declaration';

method fromObject

fromObject: (
    de: Deserializer,
    obj: JSONOutput.DeclarationReflection | JSONOutput.ProjectReflection
) => void;

method getAllSignatures

getAllSignatures: () => SignatureReflection[];

method getChildOrTypePropertyByName

getChildOrTypePropertyByName: (
    path: string[]
) => DeclarationReflection | undefined;

method getNonIndexSignatures

getNonIndexSignatures: () => SignatureReflection[];

method getProperties

getProperties: () => DeclarationReflection[];

method hasGetterOrSetter

hasGetterOrSetter: () => boolean;

method isDeclaration

isDeclaration: () => this is DeclarationReflection;

method toObject

toObject: (serializer: Serializer) => JSONOutput.DeclarationReflection;

method toString

toString: () => string;

Return a string representation of this reflection.

method traverse

traverse: (callback: TraverseCallback) => void;

class DocumentReflection

class DocumentReflection extends Reflection {}

Non-TS reflection type which is used to represent markdown documents included in the docs.

constructor

constructor(
    name: string,
    parent: Reflection,
    content: CommentDisplayPart[],
    frontmatter: Record<string, unknown>
);

property children

children?: DocumentReflection[];

Child documents, if any are present.

property content

content: CommentDisplayPart[];

The content to be displayed on the page for this reflection.

property frontmatter

frontmatter: Record<string, unknown>;

Frontmatter included in document

property relevanceBoost

relevanceBoost?: number;

A precomputed boost derived from the searchCategoryBoosts and searchGroupBoosts options, used when boosting search relevance scores at runtime. May be modified by plugins.

property variant

readonly variant: string;

method addChild

addChild: (child: DocumentReflection) => void;

method fromObject

fromObject: (de: Deserializer, obj: JSONOutput.DocumentReflection) => void;

method isDocument

isDocument: () => this is DocumentReflection;

method toObject

toObject: (serializer: Serializer) => JSONOutput.DocumentReflection;

method traverse

traverse: (callback: TraverseCallback) => void;

class FileRegistry

class FileRegistry {}

property mediaToPath

protected mediaToPath: Map<FileId, NormalizedPath>;

property mediaToReflection

protected mediaToReflection: Map<FileId, ReflectionId>;

property names

protected names: Map<FileId, string>;

property nameUsage

protected nameUsage: Map<string, number>;

property nextId

protected nextId: number;

property pathToMedia

protected pathToMedia: Map<NormalizedPath, FileId>;

property reflectionToPath

protected reflectionToPath: Map<ReflectionId, NormalizedPath>;

method fromObject

fromObject: (de: Deserializer, obj: JSONOutput.FileRegistry) => void;

Revive a file registry from disc. Note that in the packages context this may be called multiple times on a single object, and should merge in files from the other registries.

method getName

getName: (id: FileId) => string | undefined;

method getNameToAbsoluteMap

getNameToAbsoluteMap: () => ReadonlyMap<string, string>;

method getReflectionPath

getReflectionPath: (reflection: Reflection) => string | undefined;

method register

register: (
    sourcePath: NormalizedPath,
    relativePath: NormalizedPath
) => { target: FileId; anchor: string | undefined } | undefined;

method registerAbsolute

registerAbsolute: (absolute: NormalizedPath) => {
    target: FileId;
    anchor: string | undefined;
};

method registerReflection

registerReflection: (absolute: NormalizedPath, reflection: Reflection) => void;

Registers the specified path as the canonical file for this reflection

method registerReflectionPath

registerReflectionPath: (
    absolute: NormalizedPath,
    reflection: Reflection
) => void;

Registers the specified path as a path which should be resolved to the specified reflection. A reflection *may* be associated with multiple paths.

method removeReflection

removeReflection: (reflection: Reflection) => void;

method resolve

resolve: (
    id: FileId,
    project: ProjectReflection
) => string | Reflection | undefined;

method resolvePath

resolvePath: (id: FileId) => string | undefined;

method toObject

toObject: (ser: Serializer) => JSONOutput.FileRegistry;

class IndexedAccessType

class IndexedAccessType extends Type {}

Represents an indexed access type. Types

constructor

constructor(objectType: SomeType, indexType: SomeType);

property indexType

indexType: SomeType;

property objectType

objectType: SomeType;

property type

readonly type: string;

method getTypeString

protected getTypeString: () => string;

method needsParenthesis

needsParenthesis: () => boolean;

method toObject

toObject: (serializer: Serializer) => JSONOutput.IndexedAccessType;

class InferredType

class InferredType extends Type {}

Represents an inferred type, U in the example below.

type Z = Promise<string> extends Promise<infer U> : never

Types

constructor

constructor(name: string, constraint?: SomeType);

property constraint

constraint?: SomeType;

property name

name: string;

property type

readonly type: string;

method getTypeString

protected getTypeString: () => string;

method needsParenthesis

needsParenthesis: (context: TypeContext) => boolean;

method toObject

toObject: (serializer: Serializer) => JSONOutput.InferredType;

class IntersectionType

class IntersectionType extends Type {}

Represents an intersection type.
let value: A & B;
Types

constructor

constructor(types: SomeType[]);

property type

readonly type: string;

property types

types: SomeType[];

method getTypeString

protected getTypeString: () => string;

method needsParenthesis

needsParenthesis: (context: TypeContext) => boolean;

method toObject

toObject: (serializer: Serializer) => JSONOutput.IntersectionType;

class IntrinsicType

class IntrinsicType extends Type {}

Represents an intrinsic type like string or boolean.
let value: number;
Types

constructor

constructor(name: string);

property name

name: string;

property type

readonly type: string;

method getTypeString

protected getTypeString: () => string;

method needsParenthesis

needsParenthesis: () => boolean;

method toObject

toObject: () => JSONOutput.IntrinsicType;

class LiteralType

class LiteralType extends Type {}

Represents a literal type.
type A = "A" type B = 1
Types

constructor

constructor(value: string | number | bigint | boolean);

property type

readonly type: string;

property value

value: string | number | bigint | boolean;

method getTypeString

protected getTypeString: () => string;

Return a string representation of this type.

method needsParenthesis

needsParenthesis: () => boolean;

method toObject

toObject: () => JSONOutput.LiteralType;

class MappedType

class MappedType extends Type {}

Represents a mapped type.

{ -readonly [K in Parameter as Name]?: Template }

Types

constructor

constructor(
    parameter: string,
    parameterType: SomeType,
    templateType: SomeType,
    readonlyModifier?: '+' | '-',
    optionalModifier?: '+' | '-',
    nameType?: SomeType
);

property nameType

nameType?: SomeType;

property optionalModifier

optionalModifier?: '+' | '-';

property parameter

parameter: string;

property parameterType

parameterType: SomeType;

property readonlyModifier

readonlyModifier?: '+' | '-';

property templateType

templateType: SomeType;

property type

readonly type: string;

method getTypeString

protected getTypeString: () => string;

method needsParenthesis

needsParenthesis: () => boolean;

method toObject

toObject: (serializer: Serializer) => JSONOutput.MappedType;

class NamedTupleMember

class NamedTupleMember extends Type {}

Represents a named member of a tuple type.
let value: [name: string];
Types

constructor

constructor(name: string, isOptional: boolean, element: SomeType);

property element

element: SomeType;

property isOptional

isOptional: boolean;

property name

name: string;

property type

readonly type: string;

method getTypeString

protected getTypeString: () => string;

Return a string representation of this type.

method needsParenthesis

needsParenthesis: () => boolean;

method toObject

toObject: (serializer: Serializer) => JSONOutput.NamedTupleMemberType;

class OptionalType

class OptionalType extends Type {}

Represents an optional type
type Z = [1, 2?] // ^^
Types

constructor

constructor(elementType: SomeType);

property elementType

elementType: SomeType;

property type

readonly type: string;

method getTypeString

protected getTypeString: () => string;

method needsParenthesis

needsParenthesis: () => boolean;

method toObject

toObject: (serializer: Serializer) => JSONOutput.OptionalType;

class ParameterReflection

class ParameterReflection extends Reflection {}

Reflections

property defaultValue

defaultValue?: string;

property parent

parent?: SignatureReflection;

property type

type?: SomeType;

property variant

readonly variant: string;

method fromObject

fromObject: (de: Deserializer, obj: JSONOutput.ParameterReflection) => void;

method isParameter

isParameter: () => this is ParameterReflection;

method toObject

toObject: (serializer: Serializer) => JSONOutput.ParameterReflection;

method toString

toString: () => string;

Return a string representation of this reflection.

method traverse

traverse: (callback: TraverseCallback) => void;

class PredicateType

class PredicateType extends Type {}

Represents a type predicate.

function isString(x: unknown): x is string {}
function assert(condition: boolean): asserts condition {}

Types

constructor

constructor(name: string, asserts: boolean, targetType?: SomeType);

Create a new PredicateType instance.
Parameter name
The identifier name which is tested by the predicate.
Parameter asserts
True if the type is of the form asserts val is string, false if the type is of the form val is string
Parameter targetType
The type that the identifier is tested to be. May be undefined if the type is of the form asserts val. Will be defined if the type is of the form asserts val is string or val is string.

property asserts

asserts: boolean;

property name

name: string;

property targetType

targetType?: SomeType;

property type

readonly type: string;

method getTypeString

protected getTypeString: () => string;

Return a string representation of this type.

method needsParenthesis

needsParenthesis: () => boolean;

method toObject

toObject: (serializer: Serializer) => JSONOutput.PredicateType;

class ProjectReflection

class ProjectReflection extends ContainerReflection {}

A reflection that represents the root of the project.
The project reflection acts as a global index, one may receive all reflections and source files of the processed project through this reflection. Reflections

constructor

constructor(name: string, registry: FileRegistry);

property files

readonly files: FileRegistry;

Object which describes where to find content for relative links.

property packageName

packageName?: string;

The name of the package that this reflection documents according to package.json.

property packageVersion

packageVersion?: string;

The version of the package that this reflection documents according to package.json.

property readme

readme?: CommentDisplayPart[];

The contents of the readme.md file of the project when found.

property reflections

reflections: { [id: number]: Reflection };

A list of all reflections within the project. DO NOT MUTATE THIS OBJECT. All mutation should be done via registerReflection and removeReflection to ensure that links to reflections remain valid.
This may be replaced with a Map<number, Reflection> someday.

property variant

readonly variant: string;

method fromObject

fromObject: (de: Deserializer, obj: JSONOutput.ProjectReflection) => void;

method getReflectionById

getReflectionById: (id: number) => Reflection | undefined;

Gets the reflection registered for the given reflection ID, or undefined if it is not present in the project.

method getReflectionsByKind

getReflectionsByKind: (kind: ReflectionKind) => Reflection[];

Return a list of all reflections in this project of a certain kind.
Parameter kind
The desired kind of reflection.
Returns
An array containing all reflections with the desired kind.

method isProject

isProject: () => this is ProjectReflection;

Return whether this reflection is the root / project reflection.

method registerReflection

registerReflection: (
    reflection: Reflection,
    id: ReflectionSymbolId | undefined,
    filePath: NormalizedPath | undefined
) => void;

Registers the given reflection so that it can be quickly looked up by helper methods. Should be called for *every* reflection added to the project.
Note: During conversion, Context.registerReflection should be used instead so that symbols can be saved for later use.

method removeReflection

removeReflection: (reflection: Reflection) => void;

Removes a reflection from the documentation. Can be used by plugins to filter reflections out of the generated documentation. Has no effect if the reflection is not present in the project.

method removeTypeReflections

removeTypeReflections: (type: Type | undefined) => void;

Removes references to reflections contained within the provided type. Plugins which overwrite types on reflections should pass the type to this method before overwriting the property. 0.26.6

method symbolIdHasBeenRemoved

symbolIdHasBeenRemoved: (id: ReflectionSymbolId) => boolean;

method toObject

toObject: (serializer: Serializer) => JSONOutput.ProjectReflection;

class QueryType

class QueryType extends Type {}

Represents a type that is constructed by querying the type of a reflection.
const x = 1 type Z = typeof x // query on reflection for x
Types

constructor

constructor(queryType: ReferenceType);

property queryType

queryType: ReferenceType;

property type

readonly type: string;

method getTypeString

protected getTypeString: () => string;

method needsParenthesis

needsParenthesis: () => boolean;

method toObject

toObject: (serializer: Serializer) => JSONOutput.QueryType;

class ReferenceReflection

class ReferenceReflection extends DeclarationReflection {}

Describes a reflection which does not exist at this location, but is referenced. Used for imported reflections.

// a.ts
export const a = 1;
// b.ts
import { a } from './a';
// Here to avoid extra work we create a reference to the original reflection in module a instead
// of copying the reflection.
export { a };

Reflections

property variant

readonly variant: string;

method fromObject

fromObject: (de: Deserializer, obj: JSONOutput.ReferenceReflection) => void;

method getChildByName

getChildByName: (arg: string | string[]) => Reflection | undefined;

method getTargetReflection

getTargetReflection: () => Reflection;

Gets the reflection that is referenced. This may be another reference reflection. To fully resolve any references, use getTargetReflectionDeep.

method getTargetReflectionDeep

getTargetReflectionDeep: () => Reflection;

Gets the reflection that is referenced, this will fully resolve references. To only resolve one reference, use getTargetReflection.

method toObject

toObject: (serializer: Serializer) => JSONOutput.ReferenceReflection;

method tryGetTargetReflection

tryGetTargetReflection: () => Reflection | undefined;

Tries to get the reflection that is referenced. This may be another reference reflection. To fully resolve any references, use tryGetTargetReflectionDeep.

method tryGetTargetReflectionDeep

tryGetTargetReflectionDeep: () => Reflection | undefined;

Tries to get the reflection that is referenced, this will fully resolve references. To only resolve one reference, use tryGetTargetReflection.

class ReferenceType

class ReferenceType extends Type {}

Represents a type that refers to another reflection like a class, interface or enum.
let value: MyClass<T>;
Types

property externalUrl

externalUrl?: string;

If this reference type refers to a reflection defined by a project not being rendered, points to the url that this type should be linked to.

property highlightedProperties

highlightedProperties?: Map<string, CommentDisplayPart[]>;

Sometimes a few properties are more important than the rest of the properties within a type. This occurs most often with object parameters, where users want to specify @param foo.bar to highlight something about the bar property.
Does NOT support nested properties.

property name

name: string;

The name of the referenced type.
If the symbol cannot be found because it's not part of the documentation this can be used to represent the type.

property package

package?: string;

The package that this type is referencing.

property preferValues

preferValues: boolean;

If set, will prefer reflections with ReflectionKinds which represent values rather than those which represent types.

property qualifiedName

qualifiedName: string;

The fully qualified name of the referenced type, relative to the file it is defined in. This will usually be the same as name, unless namespaces are used.

property refersToTypeParameter

refersToTypeParameter: boolean;

If set, no warnings about something not being exported should be created since this may be referring to a type created with infer X which will not be registered on the project.

property reflection

readonly reflection: Reflection;

The resolved reflection.

property symbolId

readonly symbolId: ReflectionSymbolId;

If not resolved, the symbol id of the reflection, otherwise undefined.

property type

readonly type: string;

property typeArguments

typeArguments?: SomeType[];

The type arguments of this reference.

method createResolvedReference

static createResolvedReference: (
    name: string,
    target: Reflection | ReflectionId,
    project: ProjectReflection | null
) => ReferenceType;

method createUnresolvedReference

static createUnresolvedReference: (
    name: string,
    target: ReflectionSymbolId,
    project: ProjectReflection,
    qualifiedName: string
) => ReferenceType;

method fromObject

fromObject: (de: Deserializer, obj: JSONOutput.ReferenceType) => void;

method getTypeString

protected getTypeString: () => string;

method isIntentionallyBroken

isIntentionallyBroken: () => boolean;

Checks if this type is a reference type because it uses a name, but is intentionally not pointing to a reflection. This happens for type parameters and when representing a mapped type.

method needsParenthesis

needsParenthesis: () => boolean;

method toDeclarationReference

toDeclarationReference: () => DeclarationReference;

Convert this reference type to a declaration reference used for resolution of external types.

method toObject

toObject: (serializer: Serializer) => JSONOutput.ReferenceType;

class Reflection

abstract class Reflection {}

Base class for all reflection classes.
While generating a documentation, TypeDoc generates an instance of ProjectReflection as the root for all reflections within the project. All other reflections are represented by the DeclarationReflection class.
This base class exposes the basic properties one may use to traverse the reflection tree. You can use the ContainerReflection.children and parent properties to walk the tree. The ContainerReflection.groups property contains a list of all children grouped and sorted for rendering. Reflections

constructor

constructor(name: string, kind: ReflectionKind, parent?: Reflection);

property comment

comment?: Comment;

The parsed documentation comment attached to this reflection.

property flags

flags: ReflectionFlags;

property id

id: Number & { __reflectionIdBrand: never };

Unique id of this reflection.

property kind

kind: ReflectionKind;

The kind of this reflection.

property name

name: string;

The symbol name of this reflection.

property parent

parent?: Reflection;

The reflection this reflection is a child of.

property project

project: ProjectReflection;

property variant

abstract readonly variant: keyof ReflectionVariant;

Discriminator representing the type of reflection represented by this object.

method fromObject

fromObject: (de: Deserializer, obj: JSONOutput.Reflection) => void;

method getChildByName

getChildByName: (arg: string | string[]) => Reflection | undefined;

Return a child by its name.
Parameter arg
The name hierarchy of the child to look for.
Returns
The found child or undefined.

method getFriendlyFullName

getFriendlyFullName: () => string;

Return the full name of this reflection, with signature names dropped if possible without introducing ambiguity in the name.

method getFullName

getFullName: (separator?: string) => string;

Return the full name of this reflection. Intended for use in debugging. For log messages intended to be displayed to the user for them to fix, prefer getFriendlyFullName instead.
The full name contains the name of this reflection and the names of all parent reflections.
Parameter separator
Separator used to join the names of the reflections.
Returns
The full name of this reflection.

method hasComment

hasComment: (notRenderedTags?: readonly TagString[]) => boolean;

Checks if this reflection has a comment which contains any visible text.
Returns
TRUE when this reflection has a visible comment.

method hasGetterOrSetter

hasGetterOrSetter: () => boolean;

method isContainer

isContainer: () => this is ContainerReflection;

method isDeclaration

isDeclaration: () => this is DeclarationReflection;

method isDeprecated

isDeprecated: () => boolean;

Check if this reflection or any of its parents have been marked with the @deprecated tag.

method isDocument

isDocument: () => this is DocumentReflection;

method isParameter

isParameter: () => this is ParameterReflection;

method isProject

isProject: () => this is ProjectReflection;

Return whether this reflection is the root / project reflection.

method isReference

isReference: () => this is ReferenceReflection;

method isSignature

isSignature: () => this is SignatureReflection;

method isTypeParameter

isTypeParameter: () => this is TypeParameterReflection;

method kindOf

kindOf: (kind: ReflectionKind | ReflectionKind[]) => boolean;

Test whether this reflection is of the given kind.

method setFlag

setFlag: (flag: ReflectionFlag, value?: boolean) => void;

Set a flag on this reflection.

method toObject

toObject: (serializer: Serializer) => JSONOutput.Reflection;

method toString

toString: () => string;

Return a string representation of this reflection.

method toStringHierarchy

toStringHierarchy: (indent?: string) => string;

Return a string representation of this reflection and all of its children.
Note: This is intended as a debug tool only, output may change between patch versions.
Parameter indent
Used internally to indent child reflections.

method traverse

abstract traverse: (callback: TraverseCallback) => void;

Traverse most potential child reflections of this reflection.
Note: This may not necessarily traverse child reflections contained within the type property of the reflection, and should not be relied on for this. Support for checking object types will likely be removed in v0.29.
The given callback will be invoked for all children, signatures and type parameters attached to this reflection.
Parameter callback
The callback function that should be applied for each child reflection.

method visit

visit: (visitor: ReflectionVisitor) => void;

class ReflectionCategory

class ReflectionCategory {}

A category of reflections.
Reflection categories are created by the ´CategoryPlugin´ in the resolving phase of the dispatcher. The main purpose of categories is to be able to more easily render human readable children lists in templates.

constructor

constructor(title: string);

Create a new ReflectionCategory instance.
Parameter title
The title of this category.

property children

children: (DeclarationReflection | DocumentReflection)[];

All reflections of this category.

property description

description?: CommentDisplayPart[];

The user specified description, if any, set with @categoryDescription

property title

title: string;

The title, a string representation of this category.

method fromObject

fromObject: (de: Deserializer, obj: JSONOutput.ReflectionCategory) => void;

method toObject

toObject: () => JSONOutput.ReflectionCategory;

class ReflectionFlags

class ReflectionFlags {}

This must extend Array in order to work with Handlebar's each helper.

property isAbstract

readonly isAbstract: boolean;

property isConst

readonly isConst: boolean;

property isExternal

readonly isExternal: boolean;

Is this a declaration from an external document?

property isInherited

readonly isInherited: boolean;

property isOptional

readonly isOptional: boolean;

Whether this reflection is an optional component or not.
Applies to function parameters and object members.

property isPrivate

readonly isPrivate: boolean;

Is this a private member?

property isProtected

readonly isProtected: boolean;

Is this a protected member?

property isPublic

readonly isPublic: boolean;

Is this a public member?

property isReadonly

readonly isReadonly: boolean;

property isRest

readonly isRest: boolean;

Whether it's a rest parameter, like foo(...params);.

property isStatic

readonly isStatic: boolean;

Is this a static member?

method flagString

static flagString: (flag: ReflectionFlag) => TranslatedString;

method fromObject

fromObject: (obj: JSONOutput.ReflectionFlags) => void;

method getFlagStrings

getFlagStrings: () => TranslatedString[];

method hasFlag

hasFlag: (flag: ReflectionFlag) => boolean;

method setFlag

setFlag: (flag: ReflectionFlag, set: boolean) => void;

method toObject

toObject: () => JSONOutput.ReflectionFlags;

class ReflectionGroup

class ReflectionGroup {}

A group of reflections. All reflections in a group are of the same kind.
Reflection groups are created by the ´GroupHandler´ in the resolving phase of the dispatcher. The main purpose of groups is to be able to more easily render human readable children lists in templates.

constructor

constructor(title: string, owningReflection: Reflection);

Create a new ReflectionGroup instance.
Parameter title
The title of this group.
Parameter owningReflection
The reflection containing this group, useful for changing rendering based on a comment on a reflection.

property categories

categories?: ReflectionCategory[];

Categories contained within this group.

property children

children: (DeclarationReflection | DocumentReflection)[];

All reflections of this group.

property description

description?: CommentDisplayPart[];

User specified description via @groupDescription, if specified.

property owningReflection

readonly owningReflection: Reflection;

property title

title: string;

The title, a string representation of the typescript kind, of this group.

method fromObject

fromObject: (de: Deserializer, obj: JSONOutput.ReflectionGroup) => void;

method toObject

toObject: (serializer: Serializer) => JSONOutput.ReflectionGroup;

class ReflectionSymbolId

class ReflectionSymbolId {}

This exists so that TypeDoc can store a unique identifier for a ts.Symbol without keeping a reference to the ts.Symbol itself. This identifier should be stable across runs so long as the symbol is exported from the same file.

constructor

constructor(json: JSONOutput.ReflectionSymbolId);

property fileName

fileName?: NormalizedPath;

Note: This is **not** serialized, only packageName and packagePath path information is preserved when serializing. This is set so that it is available to plugins when initially converting a project.

property packageName

readonly packageName: string;

The name of the package which this symbol ID resides within.

property packagePath

readonly packagePath: NormalizedPath;

Path to the source file containing this symbol. Note that this is NOT an absolute path, but a package-relative path according to the directory containing package.json for the package name.

property pos

pos: number;

Note: This is **not** serialized. It exists for sorting by declaration order, but should not be needed when deserializing from JSON. Will be set to Infinity if the ID was deserialized from JSON.

property qualifiedName

readonly qualifiedName: string;

Qualified name of this symbol within the source file.

property transientId

transientId: number;

Note: This is **not** serialized. It exists to support detection of the differences between symbols which share declarations, but are instantiated with different type parameters. This will be NaN if the symbol reference is not transient. Note: This can only be non-NaN if pos is finite.

property UNKNOWN_PACKAGE

static readonly UNKNOWN_PACKAGE: string;

This will only be used if we somehow cannot find a package.json file for source code. This is very unlikely, but if it occurs then the packageName will be set to this string, and packagePath will have the absolute path to the source file.

method getStableKey

getStableKey: () => ReflectionSymbolIdString;

method toDeclarationReference

toDeclarationReference: () => DeclarationReference;

method toObject

toObject: () => JSONOutput.ReflectionSymbolId;

class ReflectionType

class ReflectionType extends Type {}

Represents a type which has it's own reflection like literal types. This type will likely go away at some point and be replaced by a dedicated ObjectType. Allowing reflections to be nested within types causes much pain in the rendering code.
let value: { a: string, b: number };
Types

constructor

constructor(declaration: DeclarationReflection);

property declaration

declaration: DeclarationReflection;

property type

readonly type: string;

method getTypeString

protected getTypeString: () => string;

method needsParenthesis

needsParenthesis: (where: TypeContext) => boolean;

method toObject

toObject: (serializer: Serializer) => JSONOutput.ReflectionType;

class RestType

class RestType extends Type {}

Represents a rest type
type Z = [1, ...2[]] // ^^^^^^
Types

constructor

constructor(elementType: SomeType);

property elementType

elementType: SomeType;

property type

readonly type: string;

method getTypeString

protected getTypeString: () => string;

method needsParenthesis

needsParenthesis: () => boolean;

method toObject

toObject: (serializer: Serializer) => JSONOutput.RestType;

class SignatureReflection

class SignatureReflection extends Reflection {}

Reflections

constructor

constructor(
    name: string,
    kind:
        | ReflectionKind.CallSignature
        | ReflectionKind.IndexSignature
        | ReflectionKind.ConstructorSignature
        | ReflectionKind.GetSignature
        | ReflectionKind.SetSignature,
    parent: DeclarationReflection
);

property implementationOf

implementationOf?: ReferenceType;

A type that points to the reflection this reflection is the implementation of.
Applies to class members.

property inheritedFrom

inheritedFrom?: ReferenceType;

A type that points to the reflection this reflection has been inherited from.
Applies to interface and class members.

property kind

kind:
    | ReflectionKind.CallSignature
    | ReflectionKind.IndexSignature
    | ReflectionKind.ConstructorSignature
    | ReflectionKind.GetSignature
    | ReflectionKind.SetSignature;

property overwrites

overwrites?: ReferenceType;

A type that points to the reflection that has been overwritten by this reflection.
Applies to interface and class members.

property parameters

parameters?: ParameterReflection[];

property parent

parent: DeclarationReflection;

property sources

sources?: SourceReference[];

A list of all source files that contributed to this reflection.

property type

type?: SomeType;

property typeParameters

typeParameters?: TypeParameterReflection[];

property variant

readonly variant: string;

method fromObject

fromObject: (de: Deserializer, obj: JSONOutput.SignatureReflection) => void;

method isSignature

isSignature: () => this is SignatureReflection;

method toObject

toObject: (serializer: Serializer) => JSONOutput.SignatureReflection;

method toString

toString: () => string;

Return a string representation of this reflection.

method traverse

traverse: (callback: TraverseCallback) => void;

class SourceReference

class SourceReference {}

Represents references of reflections to their defining source files.
See Also
- DeclarationReflection.sources

constructor

constructor(fileName: string, line: number, character: number);

property character

character: number;

The index of the character that emitted the declaration.

property fileName

fileName: string;

The filename of the source file.

property line

line: number;

The one based number of the line that emitted the declaration.

property url

url?: string;

URL for displaying the source file.

method equals

equals: (other: SourceReference) => boolean;

method fromObject

fromObject: (_de: Deserializer, obj: JSONOutput.SourceReference) => void;

method toObject

toObject: () => JSONOutput.SourceReference;

class TemplateLiteralType

class TemplateLiteralType extends Type {}

TS 4.1 template literal types
type Z = `${'a' | 'b'}${'a' | 'b'}`
Types

constructor

constructor(head: string, tail: [SomeType, string][]);

property head

head: string;

property tail

tail: [SomeType, string][];

property type

readonly type: string;

method getTypeString

protected getTypeString: () => string;

method needsParenthesis

needsParenthesis: () => boolean;

method toObject

toObject: (serializer: Serializer) => JSONOutput.TemplateLiteralType;

class TupleType

class TupleType extends Type {}

Represents a tuple type.
let value: [string, boolean];
Types

constructor

constructor(elements: SomeType[]);

Parameter elements
The ordered type elements of the tuple type.

property elements

elements: SomeType[];

property type

readonly type: string;

method getTypeString

protected getTypeString: () => string;

method needsParenthesis

needsParenthesis: () => boolean;

method toObject

toObject: (serializer: Serializer) => JSONOutput.TupleType;

class Type

abstract class Type {}

Base class of all type definitions. Types

property type

abstract readonly type: keyof TypeKindMap;

The type name identifier.

method estimatePrintWidth

estimatePrintWidth: () => number;

Return the estimated size of the type if it was all printed on one line.

method fromObject

fromObject: (_de: Deserializer, _obj: JSONOutput.SomeType) => void;

method getTypeString

protected abstract getTypeString: () => string;

Implementation method for toString. needsParenthesis will be used to determine if the returned string should be wrapped in parenthesis.

method needsParenthesis

abstract needsParenthesis: (context: TypeContext) => boolean;

method stringify

stringify: (context: TypeContext) => string;

method toObject

abstract toObject: (serializer: Serializer) => JSONOutput.SomeType;

method toString

toString: () => string;

Return a string representation of this type.

method visit

visit: {
    <T, A extends any[] = []>(visitor: TypeVisitor<T, A>, ...args: A): T;
    <T, A extends any[] = []>(
        visitor: Partial<TypeVisitor<T, A>>,
        ...args: A
    ): T;
};

Visit this type, returning the value returned by the visitor.

class TypeOperatorType

class TypeOperatorType extends Type {}

Represents a type operator type.
class A {} class B<T extends keyof A> {}
Types

constructor

constructor(target: SomeType, operator: 'keyof' | 'unique' | 'readonly');

property operator

operator: 'keyof' | 'unique' | 'readonly';

property target

target: SomeType;

property type

readonly type: string;

method getTypeString

protected getTypeString: () => string;

method needsParenthesis

needsParenthesis: (context: TypeContext) => boolean;

method toObject

toObject: (serializer: Serializer) => JSONOutput.TypeOperatorType;

class TypeParameterReflection

class TypeParameterReflection extends Reflection {}

Reflections

constructor

constructor(
    name: string,
    parent: Reflection,
    varianceModifier: VarianceModifier
);

property default

default?: SomeType;

property parent

parent?: DeclarationReflection | SignatureReflection;

property type

type?: SomeType;

property varianceModifier

varianceModifier?: VarianceModifier;

property variant

readonly variant: string;

method fromObject

fromObject: (de: Deserializer, obj: JSONOutput.TypeParameterReflection) => void;

method isTypeParameter

isTypeParameter: () => this is TypeParameterReflection;

method toObject

toObject: (serializer: Serializer) => JSONOutput.TypeParameterReflection;

method traverse

traverse: (_callback: TraverseCallback) => void;

class UnionType

class UnionType extends Type {}

Represents an union type.
let value: string | string[];
Types

constructor

constructor(types: SomeType[]);

property elementSummaries

elementSummaries?: CommentDisplayPart[][];

If present, there should be as many items in this array as there are items in the types array.
This member is only valid on unions which are on with a ReflectionKind kind of TypeAlias. Specifying it on any other union is undefined behavior.

property type

readonly type: string;

property types

types: SomeType[];

method fromObject

fromObject: (de: Deserializer, obj: JSONOutput.UnionType) => void;

method getTypeString

protected getTypeString: () => string;

method needsParenthesis

needsParenthesis: (context: TypeContext) => boolean;

method toObject

toObject: (serializer: Serializer) => JSONOutput.UnionType;

class UnknownType

class UnknownType extends Type {}

Represents all unknown types that cannot be converted by TypeDoc. Types

constructor

constructor(name: string);

property name

name: string;

A string representation of the type as returned from TypeScript compiler.

property type

readonly type: string;

method getTypeString

protected getTypeString: () => string;

method needsParenthesis

needsParenthesis: (context: TypeContext) => boolean;

Always returns true if not at the root level, we have no idea what's in here, so wrap it in parenthesis to be extra safe.

method toObject

toObject: () => JSONOutput.UnknownType;

interface DeclarationHierarchy

interface DeclarationHierarchy {}

Stores hierarchical type data.
See Also
- DeclarationReflection.typeHierarchy

property isTarget

isTarget?: boolean;

Is this the entry containing the target type?

property next

next?: DeclarationHierarchy;

The next hierarchy level.

property types

types: SomeType[];

The types represented by this node in the hierarchy.

interface InlineTagDisplayPart

interface InlineTagDisplayPart {}

Represents an inline tag like {@link Foo}
The @link, @linkcode, and @linkplain tags may have a target property set indicating which reflection/url they link to. They may also have a tsLinkText property which includes the part of the text which TypeScript thinks should be displayed as the link text. Comments

property kind

kind: 'inline-tag';

property tag

tag: TagString;

property target

target?: Reflection | string | ReflectionSymbolId;

property text

text: string;

property tsLinkText

tsLinkText?: string;

interface ReflectionVariant

interface ReflectionVariant {}

A map of known Reflection concrete subclasses. This is used during deserialization to reconstruct serialized objects.

property declaration

declaration: DeclarationReflection;

property document

document: DocumentReflection;

property param

param: ParameterReflection;

property project

project: ProjectReflection;

property reference

reference: ReferenceReflection;

property signature

signature: SignatureReflection;

property typeParam

typeParam: TypeParameterReflection;

interface RelativeLinkDisplayPart

interface RelativeLinkDisplayPart {}

Represents a reference to a path relative to where the comment resides. This is used to detect and copy relative image links.
Use FileRegistry to determine what path on disc this refers to.
This is used for relative links within comments/documents. It is used to mark pieces of text which need to be replaced to make links work properly. Comments

property kind

kind: 'relative-link';

property target

target: FileId | undefined;

A link to either some document outside of the project or a reflection. This may be undefined if the relative path does not exist.

property targetAnchor

targetAnchor: string | undefined;

Anchor within the target page, validated after rendering if possible

property text

text: string;

The original relative text from the parsed comment.

interface TraverseCallback

interface TraverseCallback {}

call signature

(reflection: Reflection, property: TraverseProperty):
    | boolean
    | NeverIfInternal<void>;

May return false to bail out of any further iteration. To preserve backwards compatibility, if a function returns undefined, iteration must continue.

interface TypeKindMap

interface TypeKindMap {}

Types

property array

array: ArrayType;

property conditional

conditional: ConditionalType;

property indexedAccess

indexedAccess: IndexedAccessType;

property inferred

inferred: InferredType;

property intersection

intersection: IntersectionType;

property intrinsic

intrinsic: IntrinsicType;

property literal

literal: LiteralType;

property mapped

mapped: MappedType;

property namedTupleMember

namedTupleMember: NamedTupleMember;

property optional

optional: OptionalType;

property predicate

predicate: PredicateType;

property query

query: QueryType;

property reference

reference: ReferenceType;

property reflection

reflection: ReflectionType;

property rest

rest: RestType;

property templateLiteral

templateLiteral: TemplateLiteralType;

property tuple

tuple: TupleType;

property typeOperator

typeOperator: TypeOperatorType;

property union

union: UnionType;

property unknown

unknown: UnknownType;

enum ReflectionFlag

enum ReflectionFlag {
    None = 0,
    Private = 1,
    Protected = 2,
    Public = 4,
    Static = 8,
    External = 16,
    Optional = 32,
    Rest = 64,
    Abstract = 128,
    Const = 256,
    Readonly = 512,
    Inherited = 1024,
}

member Abstract

Abstract = 128

member Const

Const = 256

member External

External = 16

member Inherited

Inherited = 1024

member None

None = 0

member Optional

Optional = 32

member Private

Private = 1

member Protected

Protected = 2

member Public

Public = 4

member Readonly

Readonly = 512

member Rest

Rest = 64

member Static

Static = 8

enum ReflectionKind

enum ReflectionKind {
    Project = 1,
    Module = 2,
    Namespace = 4,
    Enum = 8,
    EnumMember = 16,
    Variable = 32,
    Function = 64,
    Class = 128,
    Interface = 256,
    Constructor = 512,
    Property = 1024,
    Method = 2048,
    CallSignature = 4096,
    IndexSignature = 8192,
    ConstructorSignature = 16384,
    Parameter = 32768,
    TypeLiteral = 65536,
    TypeParameter = 131072,
    Accessor = 262144,
    GetSignature = 524288,
    SetSignature = 1048576,
    TypeAlias = 2097152,
    Reference = 4194304,
    Document = 8388608,
}

Defines the available reflection kinds. Reflections

member Accessor

Accessor = 262144

member CallSignature

CallSignature = 4096

member Class

Class = 128

member Constructor

Constructor = 512

member ConstructorSignature

ConstructorSignature = 16384

member Document

Document = 8388608

Generic non-ts content to be included in the generated docs as its own page.

member Enum

Enum = 8

member EnumMember

EnumMember = 16

member Function

Function = 64

member GetSignature

GetSignature = 524288

member IndexSignature

IndexSignature = 8192

member Interface

Interface = 256

member Method

Method = 2048

member Module

Module = 2

member Namespace

Namespace = 4

member Parameter

Parameter = 32768

member Project

Project = 1

member Property

Property = 1024

member Reference

Reference = 4194304

member SetSignature

SetSignature = 1048576

member TypeAlias

TypeAlias = 2097152

member TypeLiteral

TypeLiteral = 65536

member TypeParameter

TypeParameter = 131072

member Variable

Variable = 32

enum TraverseProperty

enum TraverseProperty {
    Children = 0,
    Documents = 1,
    Parameters = 2,
    TypeLiteral = 3,
    TypeParameter = 4,
    Signatures = 5,
    IndexSignature = 6,
    GetSignature = 7,
    SetSignature = 8,
}

member Children

Children = 0

member Documents

Documents = 1

member GetSignature

GetSignature = 7

member IndexSignature

IndexSignature = 6

member Parameters

Parameters = 2

member SetSignature

SetSignature = 8

member Signatures

Signatures = 5

member TypeLiteral

TypeLiteral = 3

member TypeParameter

TypeParameter = 4

type CommentDisplayPart

type CommentDisplayPart =
    /**
     * Represents a plain text portion of the comment, may contain markdown
     */
    | {
          kind: 'text';
          text: string;
      }
    /**
     * Represents a code block separated out form the plain text entry so
     * that TypeDoc knows to skip it when parsing relative links and inline tags.
     */
    | {
          kind: 'code';
          text: string;
      }
    | InlineTagDisplayPart
    | RelativeLinkDisplayPart;

Represents a parsed piece of a comment. Comments
See Also
- JSONOutput.CommentDisplayPart

type FileId

type FileId = number & {
    __mediaIdBrand: never;
};

type ReflectionId

type ReflectionId = number & {
    __reflectionIdBrand: never;
};

Alias for a number which references a reflection. -1 may be used for an invalid reflection ID.

type ReflectionSymbolIdString

type ReflectionSymbolIdString = string & {
    readonly __reflectionSymbolId: unique symbol;
};

See ReflectionSymbolId

type ReflectionVisitor

type ReflectionVisitor = {
    [K in keyof ReflectionVariant]?: (refl: ReflectionVariant[K]) => void;
};

type SomeReflection

type SomeReflection = ReflectionVariant[keyof ReflectionVariant];

type SomeType

type SomeType = TypeKindMap[keyof TypeKindMap];

Types

type TypeContext

type TypeContext = (typeof TypeContext)[keyof typeof TypeContext];

type TypeKind

type TypeKind = keyof TypeKindMap;

Types

type TypeVisitor

type TypeVisitor<T = void, A extends any[] = []> = {
    [K in TypeKind]: (type: TypeKindMap[K], ...args: A) => T;
};

type VarianceModifier

type VarianceModifier = (typeof VarianceModifier)[keyof typeof VarianceModifier];

namespace Models.ReflectionKind

namespace Models.ReflectionKind {}

Reflections

function classString

classString: (kind: ReflectionKind) => string;

function pluralString

pluralString: (kind: ReflectionKind) => string;

function singularString

singularString: (kind: ReflectionKind) => any;

type KindString

type KindString = EnumKeys<typeof ReflectionKind>;

namespace OptionDefaults

module 'dist/lib/utils/options/defaults.d.ts' {}

Defaults values for TypeDoc options

variable blockTags

const blockTags: readonly TagString[];

variable cascadedModifierTags

const cascadedModifierTags: readonly TagString[];

variable excludeNotDocumentedKinds

const excludeNotDocumentedKinds: readonly EnumKeys<typeof ReflectionKind>[];

variable excludeTags

const excludeTags: readonly TagString[];

variable highlightLanguages

const highlightLanguages: readonly BundledLanguage[];

variable ignoredHighlightLanguages

const ignoredHighlightLanguages: readonly string[];

variable inlineTags

const inlineTags: readonly TagString[];

variable kindSortOrder

const kindSortOrder: readonly EnumKeys<typeof ReflectionKind>[];

variable modifierTags

const modifierTags: readonly TagString[];

variable notRenderedTags

const notRenderedTags: readonly TagString[];

variable requiredToBeDocumented

const requiredToBeDocumented: readonly EnumKeys<typeof ReflectionKind>[];

variable sort

const sort: readonly string[];

namespace ReflectionKind

namespace ReflectionKind {}

Reflections

function classString

classString: (kind: ReflectionKind) => string;

function pluralString

pluralString: (kind: ReflectionKind) => string;

function singularString

singularString: (kind: ReflectionKind) => any;

type KindString

type KindString = EnumKeys<typeof ReflectionKind>;

Package Files (55)

Dependencies (5)

Dev Dependencies (16)

Peer Dependencies (1)

typescript

Badge

To add a badge like this oneto your package's README, use the codes available below.

You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/typedoc.

Markdown

[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/typedoc)

HTML

<a href="https://www.jsdocs.io/package/typedoc"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>

Updated 2 seconds ago.
Package analyzed in 18244 ms.
Missing or incorrect documentation? Open an issue for this package.

typedoc

Install

Overview

Index

Variables

Functions

Classes

Interfaces

Enums

Type Aliases

Namespaces

Variables

variable CommentStyle

variable EntryPointStrategy

variable PageKind

variable TypeContext

variable VarianceModifier

Functions

function makeRecursiveVisitor

function normalizePath

Parameter path

Returns

function Option

function resetReflectionID

function splitUnquotedString

Classes

class Application

Remarks

property converter

property deserializer

property entryPoints

property entryPointStrategy

property EVENT_BOOTSTRAP_END

property EVENT_PROJECT_REVIVE

property EVENT_VALIDATE_PROJECT

property files

property internationalization

property lang

property logger

property options

property outputs

property renderer

property serializer

property skipErrorChecking

property VERSION

method bootstrap

Parameter options

Parameter readers

Example 1

method bootstrapWithPlugins

method convert

Returns

method convertAndWatch

Parameter success

Returns

method generateDocs

method generateJson

Parameter out

Returns

method generateOutputs

method getDefinedEntryPoints

method getEntryPoints

method getTypeScriptPath

method getTypeScriptVersion

method toString

method validate

method watchFile

Parameter path

Parameter shouldRestart

class ArgumentsReader

constructor

property name

property order

property supportsPackages

method ignoreErrors

method read

class ArrayType

constructor

Parameter elementType

property elementType