typedoc 0.26.11 → 0.27.0-beta.0

package/dist/lib/utils/options/sources/typedoc.js

@@ -1,62 +1,45 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.addTypeDocOptions = addTypeDocOptions;
-const loggers_1 = require("../../loggers");
-const declaration_1 = require("../declaration");
-const sort_1 = require("../../sort");
-const entry_point_1 = require("../../entry-point");
-const kind_1 = require("../../../models/reflections/kind");
-const Validation = __importStar(require("../../validation"));
-const enum_1 = require("../../enum");
-const highlighter_1 = require("../../highlighter");
-const set_1 = require("../../set");
-const defaults_1 = require("../defaults");
+import { LogLevel } from "../../loggers.js";
+import { ParameterType, ParameterHint, EmitStrategy, CommentStyle, } from "../declaration.js";
+import { OptionDefaults } from "../defaults.js";
+import { SORT_STRATEGIES } from "../../sort.js";
+import { EntryPointStrategy } from "../../entry-point.js";
+import { ReflectionKind } from "../../../models/reflections/kind.js";
+import * as Validation from "../../validation.js";
+import { blockTags, inlineTags, modifierTags } from "../tsdoc-defaults.js";
+import { getEnumKeys } from "../../enum.js";
+import { getSupportedLanguagesWithoutAliases, getSupportedThemes, } from "../../highlighter.js";
+import { setDifference } from "../../set.js";
+import { extname } from "path";
+function makeTagArrayValidator(name) {
+    return (value, i18n) => {
+        if (!Validation.validate([Array, Validation.isTagString], value)) {
+            throw new Error(i18n.option_0_values_must_be_array_of_tags(name));
+        }
+    };
+}
 // For convenience, added in the same order as they are documented on the website.
-function addTypeDocOptions(options) {
+export function addTypeDocOptions(options) {
     ///////////////////////////
     // Configuration Options //
     ///////////////////////////
     options.addDeclaration({
-        type: declaration_1.ParameterType.Path,
+        type: ParameterType.Path,
         name: "options",
         help: (i18n) => i18n.help_options(),
-        hint: declaration_1.ParameterHint.File,
+        hint: ParameterHint.File,
         defaultValue: "",
     });
     options.addDeclaration({
-        type: declaration_1.ParameterType.Path,
+        type: ParameterType.Path,
         name: "tsconfig",
         help: (i18n) => i18n.help_tsconfig(),
-        hint: declaration_1.ParameterHint.File,
+        hint: ParameterHint.File,
         defaultValue: "",
     });
     options.addDeclaration({
         name: "compilerOptions",
         help: (i18n) => i18n.help_compilerOptions(),
-        type: declaration_1.ParameterType.Mixed,
+        type: ParameterType.Mixed,
         configFileOnly: true,
         validate(value, i18n) {
             if (!Validation.validate({}, value)) {
@@ -67,13 +50,13 @@ function addTypeDocOptions(options) {
     options.addDeclaration({
         name: "lang",
         help: (i18n) => i18n.help_lang(),
-        type: declaration_1.ParameterType.String,
+        type: ParameterType.String,
         defaultValue: "en",
     });
     options.addDeclaration({
         name: "locales",
         help: (i18n) => i18n.help_locales(),
-        type: declaration_1.ParameterType.Mixed,
+        type: ParameterType.Mixed,
         configFileOnly: true,
         defaultValue: {},
         validate(value, i18n) {
@@ -95,7 +78,7 @@ function addTypeDocOptions(options) {
     options.addDeclaration({
         name: "packageOptions",
         help: (i18n) => i18n.help_packageOptions(),
-        type: declaration_1.ParameterType.Mixed,
+        type: ParameterType.Mixed,
         configFileOnly: true,
         defaultValue: {},
         validate(value, i18n) {
@@ -110,60 +93,60 @@ function addTypeDocOptions(options) {
     options.addDeclaration({
         name: "entryPoints",
         help: (i18n) => i18n.help_entryPoints(),
-        type: declaration_1.ParameterType.GlobArray,
+        type: ParameterType.GlobArray,
     });
     options.addDeclaration({
         name: "entryPointStrategy",
         help: (i18n) => i18n.help_entryPointStrategy(),
-        type: declaration_1.ParameterType.Map,
-        map: entry_point_1.EntryPointStrategy,
-        defaultValue: entry_point_1.EntryPointStrategy.Resolve,
+        type: ParameterType.Map,
+        map: EntryPointStrategy,
+        defaultValue: EntryPointStrategy.Resolve,
     });
     options.addDeclaration({
         name: "alwaysCreateEntryPointModule",
         help: (i18n) => i18n.help_alwaysCreateEntryPointModule(),
-        type: declaration_1.ParameterType.Boolean,
+        type: ParameterType.Boolean,
     });
     options.addDeclaration({
         name: "projectDocuments",
         help: (i18n) => i18n.help_projectDocuments(),
-        type: declaration_1.ParameterType.GlobArray,
+        type: ParameterType.GlobArray,
     });
     options.addDeclaration({
         name: "exclude",
         help: (i18n) => i18n.help_exclude(),
-        type: declaration_1.ParameterType.GlobArray,
+        type: ParameterType.GlobArray,
     });
     options.addDeclaration({
         name: "externalPattern",
         help: (i18n) => i18n.help_externalPattern(),
-        type: declaration_1.ParameterType.GlobArray,
+        type: ParameterType.GlobArray,
         defaultValue: ["**/node_modules/**"],
     });
     options.addDeclaration({
         name: "excludeExternals",
         help: (i18n) => i18n.help_excludeExternals(),
-        type: declaration_1.ParameterType.Boolean,
+        type: ParameterType.Boolean,
     });
     options.addDeclaration({
         name: "excludeNotDocumented",
         help: (i18n) => i18n.help_excludeNotDocumented(),
-        type: declaration_1.ParameterType.Boolean,
+        type: ParameterType.Boolean,
     });
     options.addDeclaration({
         name: "excludeNotDocumentedKinds",
         help: (i18n) => i18n.help_excludeNotDocumentedKinds(),
-        type: declaration_1.ParameterType.Array,
+        type: ParameterType.Array,
         validate(value, i18n) {
             const invalid = new Set(value);
-            const valid = new Set((0, enum_1.getEnumKeys)(kind_1.ReflectionKind));
+            const valid = new Set(getEnumKeys(ReflectionKind));
             for (const notPermitted of [
-                kind_1.ReflectionKind.Project,
-                kind_1.ReflectionKind.TypeLiteral,
-                kind_1.ReflectionKind.TypeParameter,
-                kind_1.ReflectionKind.Parameter,
+                ReflectionKind.Project,
+                ReflectionKind.TypeLiteral,
+                ReflectionKind.TypeParameter,
+                ReflectionKind.Parameter,
             ]) {
-                valid.delete(kind_1.ReflectionKind[notPermitted]);
+                valid.delete(ReflectionKind[notPermitted]);
             }
             for (const v of valid) {
                 invalid.delete(v);
@@ -172,39 +155,39 @@ function addTypeDocOptions(options) {
                 throw new Error(i18n.exclude_not_documented_specified_0_valid_values_are_1(Array.from(invalid).join(", "), Array.from(valid).join(", ")));
             }
         },
-        defaultValue: defaults_1.OptionDefaults.excludeNotDocumentedKinds,
+        defaultValue: OptionDefaults.excludeNotDocumentedKinds,
     });
     options.addDeclaration({
         name: "excludeInternal",
         help: (i18n) => i18n.help_excludeInternal(),
-        type: declaration_1.ParameterType.Boolean,
+        type: ParameterType.Boolean,
     });
     options.addDeclaration({
         name: "excludeCategories",
         help: (i18n) => i18n.help_excludeCategories(),
-        type: declaration_1.ParameterType.Array,
+        type: ParameterType.Array,
         defaultValue: [],
     });
     options.addDeclaration({
         name: "excludePrivate",
         help: (i18n) => i18n.help_excludePrivate(),
-        type: declaration_1.ParameterType.Boolean,
+        type: ParameterType.Boolean,
         defaultValue: true,
     });
     options.addDeclaration({
         name: "excludeProtected",
         help: (i18n) => i18n.help_excludeProtected(),
-        type: declaration_1.ParameterType.Boolean,
+        type: ParameterType.Boolean,
     });
     options.addDeclaration({
         name: "excludeReferences",
         help: (i18n) => i18n.help_excludeReferences(),
-        type: declaration_1.ParameterType.Boolean,
+        type: ParameterType.Boolean,
     });
     options.addDeclaration({
         name: "externalSymbolLinkMappings",
         help: (i18n) => i18n.help_externalSymbolLinkMappings(),
-        type: declaration_1.ParameterType.Mixed,
+        type: ParameterType.Mixed,
         defaultValue: {},
         validate(value, i18n) {
             if (!Validation.validate({}, value)) {
@@ -225,36 +208,59 @@ function addTypeDocOptions(options) {
     ///////////////////////////
     ///// Output Options //////
     ///////////////////////////
+    options.addDeclaration({
+        name: "outputs",
+        help: (i18n) => i18n.help_out(),
+        type: ParameterType.Mixed,
+        configFileOnly: true,
+        defaultValue: undefined,
+        validate(value, i18n) {
+            if (!Validation.validate([
+                Array,
+                {
+                    name: String,
+                    path: String,
+                    options: Validation.optional({
+                        [Validation.additionalProperties]: true,
+                    }),
+                },
+            ], value)) {
+                throw new Error(i18n.option_outputs_must_be_array());
+            }
+        },
+    });
     options.addDeclaration({
         name: "out",
+        outputShortcut: "html",
         help: (i18n) => i18n.help_out(),
-        type: declaration_1.ParameterType.Path,
-        hint: declaration_1.ParameterHint.Directory,
+        type: ParameterType.Path,
+        hint: ParameterHint.Directory,
         defaultValue: "./docs",
     });
     options.addDeclaration({
         name: "json",
+        outputShortcut: "json",
         help: (i18n) => i18n.help_json(),
-        type: declaration_1.ParameterType.Path,
-        hint: declaration_1.ParameterHint.File,
+        type: ParameterType.Path,
+        hint: ParameterHint.File,
     });
     options.addDeclaration({
         name: "pretty",
         help: (i18n) => i18n.help_pretty(),
-        type: declaration_1.ParameterType.Boolean,
+        type: ParameterType.Boolean,
         defaultValue: true,
     });
     options.addDeclaration({
         name: "emit",
         help: (i18n) => i18n.help_emit(),
-        type: declaration_1.ParameterType.Map,
-        map: declaration_1.EmitStrategy,
+        type: ParameterType.Map,
+        map: EmitStrategy,
         defaultValue: "docs",
     });
     options.addDeclaration({
         name: "theme",
         help: (i18n) => i18n.help_theme(),
-        type: declaration_1.ParameterType.String,
+        type: ParameterType.String,
         defaultValue: "default",
     });
     const defaultLightTheme = "light-plus";
@@ -262,51 +268,57 @@ function addTypeDocOptions(options) {
     options.addDeclaration({
         name: "lightHighlightTheme",
         help: (i18n) => i18n.help_lightHighlightTheme(),
-        type: declaration_1.ParameterType.String,
+        type: ParameterType.String,
         defaultValue: defaultLightTheme,
         validate(value, i18n) {
-            if (!(0, highlighter_1.getSupportedThemes)().includes(value)) {
-                throw new Error(i18n.highlight_theme_0_must_be_one_of_1("lightHighlightTheme", (0, highlighter_1.getSupportedThemes)().join(", ")));
+            if (!getSupportedThemes().includes(value)) {
+                throw new Error(i18n.highlight_theme_0_must_be_one_of_1("lightHighlightTheme", getSupportedThemes().join(", ")));
             }
         },
     });
     options.addDeclaration({
         name: "darkHighlightTheme",
         help: (i18n) => i18n.help_darkHighlightTheme(),
-        type: declaration_1.ParameterType.String,
+        type: ParameterType.String,
         defaultValue: defaultDarkTheme,
         validate(value, i18n) {
-            if (!(0, highlighter_1.getSupportedThemes)().includes(value)) {
-                throw new Error(i18n.highlight_theme_0_must_be_one_of_1("darkHighlightTheme", (0, highlighter_1.getSupportedThemes)().join(", ")));
+            if (!getSupportedThemes().includes(value)) {
+                throw new Error(i18n.highlight_theme_0_must_be_one_of_1("darkHighlightTheme", getSupportedThemes().join(", ")));
             }
         },
     });
     options.addDeclaration({
         name: "highlightLanguages",
         help: (i18n) => i18n.help_highlightLanguages(),
-        type: declaration_1.ParameterType.Array,
-        defaultValue: defaults_1.OptionDefaults.highlightLanguages,
+        type: ParameterType.Array,
+        defaultValue: OptionDefaults.highlightLanguages,
         validate(value, i18n) {
-            const invalid = (0, set_1.setDifference)(value, (0, highlighter_1.getSupportedLanguagesWithoutAliases)());
+            const invalid = setDifference(value, getSupportedLanguagesWithoutAliases());
             if (invalid.size) {
                 throw new Error(i18n.highlightLanguages_contains_invalid_languages_0(Array.from(invalid).join(", ")));
             }
         },
     });
+    options.addDeclaration({
+        name: "typePrintWidth",
+        help: (i18n) => i18n.help_typePrintWidth(),
+        type: ParameterType.Number,
+        defaultValue: 80,
+    });
     options.addDeclaration({
         name: "customCss",
         help: (i18n) => i18n.help_customCss(),
-        type: declaration_1.ParameterType.Path,
+        type: ParameterType.Path,
     });
     options.addDeclaration({
         name: "customJs",
         help: (i18n) => i18n.help_customJs(),
-        type: declaration_1.ParameterType.Path,
+        type: ParameterType.Path,
     });
     options.addDeclaration({
         name: "markdownItOptions",
         help: (i18n) => i18n.help_markdownItOptions(),
-        type: declaration_1.ParameterType.Mixed,
+        type: ParameterType.Mixed,
         configFileOnly: true,
         defaultValue: {
             html: true,
@@ -321,7 +333,7 @@ function addTypeDocOptions(options) {
     options.addDeclaration({
         name: "markdownItLoader",
         help: (i18n) => i18n.help_markdownItLoader(),
-        type: declaration_1.ParameterType.Mixed,
+        type: ParameterType.Mixed,
         configFileOnly: true,
         defaultValue: () => { },
         validate(value, i18n) {
@@ -334,7 +346,7 @@ function addTypeDocOptions(options) {
         name: "maxTypeConversionDepth",
         help: (i18n) => i18n.help_maxTypeConversionDepth(),
         defaultValue: 10,
-        type: declaration_1.ParameterType.Number,
+        type: ParameterType.Number,
     });
     options.addDeclaration({
         name: "name",
@@ -343,12 +355,12 @@ function addTypeDocOptions(options) {
     options.addDeclaration({
         name: "includeVersion",
         help: (i18n) => i18n.help_includeVersion(),
-        type: declaration_1.ParameterType.Boolean,
+        type: ParameterType.Boolean,
     });
     options.addDeclaration({
         name: "disableSources",
         help: (i18n) => i18n.help_disableSources(),
-        type: declaration_1.ParameterType.Boolean,
+        type: ParameterType.Boolean,
     });
     options.addDeclaration({
         name: "sourceLinkTemplate",
@@ -366,48 +378,47 @@ function addTypeDocOptions(options) {
     options.addDeclaration({
         name: "disableGit",
         help: (i18n) => i18n.help_disableGit(),
-        type: declaration_1.ParameterType.Boolean,
+        type: ParameterType.Boolean,
     });
     options.addDeclaration({
         name: "basePath",
         help: (i18n) => i18n.help_basePath(),
-        type: declaration_1.ParameterType.Path,
-    });
-    options.addDeclaration({
-        name: "excludeTags",
-        help: (i18n) => i18n.help_excludeTags(),
-        type: declaration_1.ParameterType.Array,
-        defaultValue: defaults_1.OptionDefaults.excludeTags,
-        validate(value, i18n) {
-            if (!Validation.validate([Array, Validation.isTagString], value)) {
-                throw new Error(i18n.option_0_values_must_be_array_of_tags("excludeTags"));
-            }
-        },
+        type: ParameterType.Path,
     });
     options.addDeclaration({
         name: "readme",
         help: (i18n) => i18n.help_readme(),
-        type: declaration_1.ParameterType.Path,
+        type: ParameterType.Path,
     });
     options.addDeclaration({
         name: "cname",
         help: (i18n) => i18n.help_cname(),
     });
+    options.addDeclaration({
+        name: "favicon",
+        help: (i18n) => i18n.help_favicon(),
+        validate(value, i18n) {
+            if (![".ico", ".svg"].includes(extname(value))) {
+                throw new Error(i18n.favicon_must_be_ico_or_svg());
+            }
+        },
+        type: ParameterType.Path,
+    });
     options.addDeclaration({
         name: "sourceLinkExternal",
         help: (i18n) => i18n.help_sourceLinkExternal(),
-        type: declaration_1.ParameterType.Boolean,
+        type: ParameterType.Boolean,
     });
     options.addDeclaration({
         name: "markdownLinkExternal",
         help: (i18n) => i18n.help_markdownLinkExternal(),
-        type: declaration_1.ParameterType.Boolean,
+        type: ParameterType.Boolean,
         defaultValue: true,
     });
     options.addDeclaration({
         name: "githubPages",
         help: (i18n) => i18n.help_githubPages(),
-        type: declaration_1.ParameterType.Boolean,
+        type: ParameterType.Boolean,
         defaultValue: true,
     });
     options.addDeclaration({
@@ -422,59 +433,53 @@ function addTypeDocOptions(options) {
     options.addDeclaration({
         name: "useHostedBaseUrlForAbsoluteLinks",
         help: (i18n) => i18n.help_useHostedBaseUrlForAbsoluteLinks(),
-        type: declaration_1.ParameterType.Boolean,
+        type: ParameterType.Boolean,
     });
     options.addDeclaration({
         name: "hideGenerator",
         help: (i18n) => i18n.help_hideGenerator(),
-        type: declaration_1.ParameterType.Boolean,
+        type: ParameterType.Boolean,
     });
     options.addDeclaration({
         name: "customFooterHtml",
         help: (i18n) => i18n.help_customFooterHtml(),
-        type: declaration_1.ParameterType.String,
+        type: ParameterType.String,
     });
     options.addDeclaration({
         name: "customFooterHtmlDisableWrapper",
         help: (i18n) => i18n.help_customFooterHtmlDisableWrapper(),
-        type: declaration_1.ParameterType.Boolean,
-    });
-    options.addDeclaration({
-        name: "hideParameterTypesInTitle",
-        help: (i18n) => i18n.help_hideParameterTypesInTitle(),
-        type: declaration_1.ParameterType.Boolean,
-        defaultValue: true,
+        type: ParameterType.Boolean,
     });
     options.addDeclaration({
         name: "cacheBust",
         help: (i18n) => i18n.help_cacheBust(),
-        type: declaration_1.ParameterType.Boolean,
+        type: ParameterType.Boolean,
     });
     options.addDeclaration({
         name: "searchInComments",
         help: (i18n) => i18n.help_searchInComments(),
-        type: declaration_1.ParameterType.Boolean,
+        type: ParameterType.Boolean,
     });
     options.addDeclaration({
         name: "searchInDocuments",
         help: (i18n) => i18n.help_searchInDocuments(),
-        type: declaration_1.ParameterType.Boolean,
+        type: ParameterType.Boolean,
     });
     options.addDeclaration({
         name: "cleanOutputDir",
         help: (i18n) => i18n.help_cleanOutputDir(),
-        type: declaration_1.ParameterType.Boolean,
+        type: ParameterType.Boolean,
         defaultValue: true,
     });
     options.addDeclaration({
         name: "titleLink",
         help: (i18n) => i18n.help_titleLink(),
-        type: declaration_1.ParameterType.String,
+        type: ParameterType.String,
     });
     options.addDeclaration({
         name: "navigationLinks",
         help: (i18n) => i18n.help_navigationLinks(),
-        type: declaration_1.ParameterType.Mixed,
+        type: ParameterType.Mixed,
         defaultValue: {},
         validate(value, i18n) {
             if (!isObject(value)) {
@@ -488,7 +493,7 @@ function addTypeDocOptions(options) {
     options.addDeclaration({
         name: "sidebarLinks",
         help: (i18n) => i18n.help_sidebarLinks(),
-        type: declaration_1.ParameterType.Mixed,
+        type: ParameterType.Mixed,
         defaultValue: {},
         validate(value, i18n) {
             if (!isObject(value)) {
@@ -502,12 +507,12 @@ function addTypeDocOptions(options) {
     options.addDeclaration({
         name: "navigationLeaves",
         help: (i18n) => i18n.help_navigationLeaves(),
-        type: declaration_1.ParameterType.Array,
+        type: ParameterType.Array,
     });
     options.addDeclaration({
         name: "navigation",
         help: (i18n) => i18n.help_navigation(),
-        type: declaration_1.ParameterType.Flags,
+        type: ParameterType.Flags,
         defaults: {
             includeCategories: false,
             includeGroups: false,
@@ -519,16 +524,24 @@ function addTypeDocOptions(options) {
     options.addDeclaration({
         name: "headings",
         help: (i18n) => i18n.help_headings(),
-        type: declaration_1.ParameterType.Flags,
+        type: ParameterType.Flags,
         defaults: {
             readme: true,
             document: false,
         },
     });
+    options.addDeclaration({
+        name: "sluggerConfiguration",
+        help: (i18n) => i18n.help_sluggerConfiguration(),
+        type: ParameterType.Flags,
+        defaults: {
+            lowercase: true,
+        },
+    });
     options.addDeclaration({
         name: "visibilityFilters",
         help: (i18n) => i18n.help_visibilityFilters(),
-        type: declaration_1.ParameterType.Mixed,
+        type: ParameterType.Mixed,
         configFileOnly: true,
         defaultValue: {
             protected: false,
@@ -554,7 +567,7 @@ function addTypeDocOptions(options) {
     options.addDeclaration({
         name: "searchCategoryBoosts",
         help: (i18n) => i18n.help_searchCategoryBoosts(),
-        type: declaration_1.ParameterType.Mixed,
+        type: ParameterType.Mixed,
         configFileOnly: true,
         defaultValue: {},
         validate(value, i18n) {
@@ -569,7 +582,7 @@ function addTypeDocOptions(options) {
     options.addDeclaration({
         name: "searchGroupBoosts",
         help: (i18n) => i18n.help_searchGroupBoosts(),
-        type: declaration_1.ParameterType.Mixed,
+        type: ParameterType.Mixed,
         configFileOnly: true,
         defaultValue: {},
         validate(value, i18n) {
@@ -581,13 +594,18 @@ function addTypeDocOptions(options) {
             }
         },
     });
+    options.addDeclaration({
+        name: "useFirstParagraphOfCommentAsSummary",
+        help: (i18n) => i18n.help_useFirstParagraphOfCommentAsSummary(),
+        type: ParameterType.Boolean,
+    });
     ///////////////////////////
     ///// Comment Options /////
     ///////////////////////////
     options.addDeclaration({
         name: "jsDocCompatibility",
         help: (i18n) => i18n.help_jsDocCompatibility(),
-        type: declaration_1.ParameterType.Flags,
+        type: ParameterType.Flags,
         defaults: {
             defaultTag: true,
             exampleTag: true,
@@ -598,70 +616,69 @@ function addTypeDocOptions(options) {
     options.addDeclaration({
         name: "suppressCommentWarningsInDeclarationFiles",
         help: (i18n) => i18n.help_lang(),
-        type: declaration_1.ParameterType.Boolean,
+        type: ParameterType.Boolean,
+        defaultValue: true,
     });
     options.addDeclaration({
         name: "commentStyle",
         help: (i18n) => i18n.help_commentStyle(),
-        type: declaration_1.ParameterType.Map,
-        map: declaration_1.CommentStyle,
-        defaultValue: declaration_1.CommentStyle.JSDoc,
+        type: ParameterType.Map,
+        map: CommentStyle,
+        defaultValue: CommentStyle.JSDoc,
     });
     options.addDeclaration({
         name: "useTsLinkResolution",
         help: (i18n) => i18n.help_useTsLinkResolution(),
-        type: declaration_1.ParameterType.Boolean,
+        type: ParameterType.Boolean,
         defaultValue: true,
     });
     options.addDeclaration({
         name: "preserveLinkText",
         help: (i18n) => i18n.help_preserveLinkText(),
-        type: declaration_1.ParameterType.Boolean,
+        type: ParameterType.Boolean,
         defaultValue: true,
     });
     options.addDeclaration({
         name: "blockTags",
         help: (i18n) => i18n.help_blockTags(),
-        type: declaration_1.ParameterType.Array,
-        defaultValue: defaults_1.OptionDefaults.blockTags,
-        validate(value, i18n) {
-            if (!Validation.validate([Array, Validation.isTagString], value)) {
-                throw new Error(i18n.option_0_values_must_be_array_of_tags("blockTags"));
-            }
-        },
+        type: ParameterType.Array,
+        defaultValue: blockTags,
+        validate: makeTagArrayValidator("blockTags"),
     });
     options.addDeclaration({
         name: "inlineTags",
         help: (i18n) => i18n.help_inlineTags(),
-        type: declaration_1.ParameterType.Array,
-        defaultValue: defaults_1.OptionDefaults.inlineTags,
-        validate(value, i18n) {
-            if (!Validation.validate([Array, Validation.isTagString], value)) {
-                throw new Error(i18n.option_0_values_must_be_array_of_tags("inlineTags"));
-            }
-        },
+        type: ParameterType.Array,
+        defaultValue: inlineTags,
+        validate: makeTagArrayValidator("inlineTags"),
     });
     options.addDeclaration({
         name: "modifierTags",
         help: (i18n) => i18n.help_modifierTags(),
-        type: declaration_1.ParameterType.Array,
-        defaultValue: defaults_1.OptionDefaults.modifierTags,
-        validate(value, i18n) {
-            if (!Validation.validate([Array, Validation.isTagString], value)) {
-                throw new Error(i18n.option_0_values_must_be_array_of_tags("modifierTags"));
-            }
-        },
+        type: ParameterType.Array,
+        defaultValue: modifierTags,
+        validate: makeTagArrayValidator("modifierTags"),
+    });
+    options.addDeclaration({
+        name: "excludeTags",
+        help: (i18n) => i18n.help_excludeTags(),
+        type: ParameterType.Array,
+        defaultValue: OptionDefaults.excludeTags,
+        validate: makeTagArrayValidator("excludeTags"),
+    });
+    options.addDeclaration({
+        name: "notRenderedTags",
+        help: (i18n) => i18n.help_notRenderedTags(),
+        type: ParameterType.Array,
+        defaultValue: OptionDefaults.notRenderedTags,
+        validate: makeTagArrayValidator("notRenderedTags"),
     });
     options.addDeclaration({
         name: "cascadedModifierTags",
         help: (i18n) => i18n.help_modifierTags(),
-        type: declaration_1.ParameterType.Array,
-        defaultValue: defaults_1.OptionDefaults.cascadedModifierTags,
-        validate(value, i18n) {
-            if (!Validation.validate([Array, Validation.isTagString], value)) {
-                throw new Error(i18n.option_0_values_must_be_array_of_tags("cascadedModifierTags"));
-            }
-        },
+        type: ParameterType.Array,
+        defaultValue: OptionDefaults.cascadedModifierTags,
+        validate: makeTagArrayValidator("cascadedModifierTags"),
     });
     ///////////////////////////
     // Organization Options ///
@@ -669,7 +686,13 @@ function addTypeDocOptions(options) {
     options.addDeclaration({
         name: "categorizeByGroup",
         help: (i18n) => i18n.help_categorizeByGroup(),
-        type: declaration_1.ParameterType.Boolean,
+        type: ParameterType.Boolean,
+        defaultValue: false,
+    });
+    options.addDeclaration({
+        name: "groupReferencesByType",
+        help: (i18n) => i18n.help_groupReferencesByType(),
+        type: ParameterType.Boolean,
         defaultValue: false,
     });
     options.addDeclaration({
@@ -680,44 +703,44 @@ function addTypeDocOptions(options) {
     options.addDeclaration({
         name: "categoryOrder",
         help: (i18n) => i18n.help_categoryOrder(),
-        type: declaration_1.ParameterType.Array,
+        type: ParameterType.Array,
     });
     options.addDeclaration({
         name: "groupOrder",
         help: (i18n) => i18n.help_groupOrder(),
-        type: declaration_1.ParameterType.Array,
+        type: ParameterType.Array,
         // default order specified in GroupPlugin to correctly handle localization.
     });
     options.addDeclaration({
         name: "sort",
         help: (i18n) => i18n.help_sort(),
-        type: declaration_1.ParameterType.Array,
-        defaultValue: defaults_1.OptionDefaults.sort,
+        type: ParameterType.Array,
+        defaultValue: OptionDefaults.sort,
         validate(value, i18n) {
             const invalid = new Set(value);
-            for (const v of sort_1.SORT_STRATEGIES) {
+            for (const v of SORT_STRATEGIES) {
                 invalid.delete(v);
             }
             if (invalid.size !== 0) {
-                throw new Error(i18n.option_0_specified_1_but_only_2_is_valid("sort", Array.from(invalid).join(", "), sort_1.SORT_STRATEGIES.join(", ")));
+                throw new Error(i18n.option_0_specified_1_but_only_2_is_valid("sort", Array.from(invalid).join(", "), SORT_STRATEGIES.join(", ")));
             }
         },
     });
     options.addDeclaration({
         name: "sortEntryPoints",
         help: (i18n) => i18n.help_sortEntryPoints(),
-        type: declaration_1.ParameterType.Boolean,
+        type: ParameterType.Boolean,
         defaultValue: true,
     });
     options.addDeclaration({
         name: "kindSortOrder",
         help: (i18n) => i18n.help_kindSortOrder(),
-        type: declaration_1.ParameterType.Array,
+        type: ParameterType.Array,
         defaultValue: [],
         validate(value, i18n) {
-            const invalid = (0, set_1.setDifference)(value, (0, enum_1.getEnumKeys)(kind_1.ReflectionKind));
+            const invalid = setDifference(value, getEnumKeys(ReflectionKind));
             if (invalid.size !== 0) {
-                throw new Error(i18n.option_0_specified_1_but_only_2_is_valid(`kindSortOrder`, Array.from(invalid).join(", "), (0, enum_1.getEnumKeys)(kind_1.ReflectionKind).join(", ")));
+                throw new Error(i18n.option_0_specified_1_but_only_2_is_valid(`kindSortOrder`, Array.from(invalid).join(", "), getEnumKeys(ReflectionKind).join(", ")));
             }
         },
     });
@@ -727,84 +750,85 @@ function addTypeDocOptions(options) {
     options.addDeclaration({
         name: "watch",
         help: (i18n) => i18n.help_watch(),
-        type: declaration_1.ParameterType.Boolean,
+        type: ParameterType.Boolean,
     });
     options.addDeclaration({
         name: "preserveWatchOutput",
         help: (i18n) => i18n.help_preserveWatchOutput(),
-        type: declaration_1.ParameterType.Boolean,
+        type: ParameterType.Boolean,
     });
     options.addDeclaration({
         name: "skipErrorChecking",
         help: (i18n) => i18n.help_skipErrorChecking(),
-        type: declaration_1.ParameterType.Boolean,
+        type: ParameterType.Boolean,
         defaultValue: false,
     });
     options.addDeclaration({
         name: "help",
         help: (i18n) => i18n.help_help(),
-        type: declaration_1.ParameterType.Boolean,
+        type: ParameterType.Boolean,
     });
     options.addDeclaration({
         name: "version",
         help: (i18n) => i18n.help_version(),
-        type: declaration_1.ParameterType.Boolean,
+        type: ParameterType.Boolean,
     });
     options.addDeclaration({
         name: "showConfig",
         help: (i18n) => i18n.help_showConfig(),
-        type: declaration_1.ParameterType.Boolean,
+        type: ParameterType.Boolean,
     });
     options.addDeclaration({
         name: "plugin",
         help: (i18n) => i18n.help_plugin(),
-        type: declaration_1.ParameterType.ModuleArray,
+        type: ParameterType.ModuleArray,
     });
     options.addDeclaration({
         name: "logLevel",
         help: (i18n) => i18n.help_logLevel(),
-        type: declaration_1.ParameterType.Map,
-        map: loggers_1.LogLevel,
-        defaultValue: loggers_1.LogLevel.Info,
+        type: ParameterType.Map,
+        map: LogLevel,
+        defaultValue: LogLevel.Info,
     });
     options.addDeclaration({
         name: "treatWarningsAsErrors",
         help: (i18n) => i18n.help_treatWarningsAsErrors(),
-        type: declaration_1.ParameterType.Boolean,
+        type: ParameterType.Boolean,
     });
     options.addDeclaration({
         name: "treatValidationWarningsAsErrors",
         help: (i18n) => i18n.help_treatValidationWarningsAsErrors(),
-        type: declaration_1.ParameterType.Boolean,
+        type: ParameterType.Boolean,
     });
     options.addDeclaration({
         name: "intentionallyNotExported",
         help: (i18n) => i18n.help_intentionallyNotExported(),
-        type: declaration_1.ParameterType.Array,
+        type: ParameterType.Array,
     });
     options.addDeclaration({
         name: "requiredToBeDocumented",
         help: (i18n) => i18n.help_requiredToBeDocumented(),
-        type: declaration_1.ParameterType.Array,
+        type: ParameterType.Array,
         validate(values, i18n) {
             // this is good enough because the values of the ReflectionKind enum are all numbers
-            const validValues = (0, enum_1.getEnumKeys)(kind_1.ReflectionKind);
+            const validValues = getEnumKeys(ReflectionKind);
             for (const kind of values) {
                 if (!validValues.includes(kind)) {
                     throw new Error(i18n.option_0_specified_1_but_only_2_is_valid("requiredToBeDocumented", kind, validValues.join(", ")));
                 }
             }
         },
-        defaultValue: defaults_1.OptionDefaults.requiredToBeDocumented,
+        defaultValue: OptionDefaults.requiredToBeDocumented,
     });
     options.addDeclaration({
         name: "validation",
         help: (i18n) => i18n.help_validation(),
-        type: declaration_1.ParameterType.Flags,
+        type: ParameterType.Flags,
         defaults: {
             notExported: true,
             invalidLink: true,
             notDocumented: false,
+            unusedMergeModuleWith: true,
         },
     });
 }