@cparra/apexdocs 3.0.0-rc.0 → 3.1.0

package/dist/cli/generate.js

@@ -1,3091 +1,45 @@
 #!/usr/bin/env node
 'use strict';
 
-var _function = require('fp-ts/function');
-var TE = require('fp-ts/TaskEither');
-var yaml = require('js-yaml');
-var path = require('path');
-var E = require('fp-ts/Either');
-var T = require('fp-ts/Task');
-var A = require('fp-ts/lib/Array');
-var apexReflection = require('@cparra/apex-reflection');
-var O = require('fp-ts/Option');
-var fastXmlParser = require('fast-xml-parser');
-var Handlebars = require('handlebars');
-var defaults = require('../defaults-DGKfeZq-.js');
-var fs = require('fs');
-var TE$1 = require('fp-ts/lib/TaskEither');
-var chalk = require('chalk');
-var cosmiconfig = require('cosmiconfig');
-var yargs = require('yargs');
-var cosmiconfigTypescriptLoader = require('cosmiconfig-typescript-loader');
-
-function _interopNamespaceDefault(e) {
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n.default = e;
-  return Object.freeze(n);
-}
-
-var TE__namespace = /*#__PURE__*/_interopNamespaceDefault(TE);
-var yaml__namespace = /*#__PURE__*/_interopNamespaceDefault(yaml);
-var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
-var E__namespace = /*#__PURE__*/_interopNamespaceDefault(E);
-var T__namespace = /*#__PURE__*/_interopNamespaceDefault(T);
-var A__namespace = /*#__PURE__*/_interopNamespaceDefault(A);
-var O__namespace = /*#__PURE__*/_interopNamespaceDefault(O);
-var fs__namespace = /*#__PURE__*/_interopNamespaceDefault(fs);
-var TE__namespace$1 = /*#__PURE__*/_interopNamespaceDefault(TE$1);
-var yargs__namespace = /*#__PURE__*/_interopNamespaceDefault(yargs);
-
-function apply(fn, ...front) {
-  return (...tailArgs) => fn(...front, ...tailArgs);
-}
-
-function defaultGetEmailByReference(email) {
-  return {
-    __type: "link",
-    title: email,
-    url: `mailto:${email}`
-  };
-}
-function replaceInlineReferences(text, linkReplacer, emailReplacer = defaultGetEmailByReference) {
-  const inlineLinks = apply(replaceInlineLinks, linkReplacer);
-  const inlineEmails = apply(replaceInlineEmails, emailReplacer);
-  return _function.pipe(inlineCode$1([text]), inlineLinks, inlineEmails);
-}
-function inlineCode$1(renderableContents) {
-  return renderableContents.flatMap((renderableContent) => inlineCodeContent(renderableContent));
-}
-function inlineCodeContent(renderableContent) {
-  if (typeof renderableContent !== "string") {
-    return [renderableContent];
-  }
-  function inlineCodeLink(text2) {
-    return {
-      __type: "inline-code",
-      content: text2
-    };
-  }
-  const text = renderableContent;
-  const codeFormatRegEx = "`([^`]*)`";
-  const matches = match(codeFormatRegEx, text);
-  return createRenderableContents(matches, text, inlineCodeLink);
-}
-function replaceInlineLinks(getLinkByTypeName, renderableContents) {
-  return renderableContents.flatMap((renderableContent) => inlineLinkContent(renderableContent, getLinkByTypeName));
-}
-function inlineLinkContent(renderableContent, getLinkByTypeName) {
-  if (typeof renderableContent !== "string") {
-    return [renderableContent];
-  }
-  const text = renderableContent;
-  const linkFormatRegEx = "{@link (.*?)}|<<([^>]+)>>";
-  const matches = match(linkFormatRegEx, text);
-  return createRenderableContents(matches, text, getLinkByTypeName);
-}
-function replaceInlineEmails(getLinkByTypeName, renderableContents) {
-  return renderableContents.flatMap((renderableContent) => inlineEmailContent(renderableContent, getLinkByTypeName));
-}
-function inlineEmailContent(renderableContent, getLinkByTypeName) {
-  if (typeof renderableContent !== "string") {
-    return [renderableContent];
-  }
-  const text = renderableContent;
-  const linkFormatRegEx = "{@email (.*?)}";
-  const matches = match(linkFormatRegEx, text);
-  return createRenderableContents(matches, text, getLinkByTypeName);
-}
-function match(regex, text) {
-  const expression = new RegExp(regex, "gi");
-  let match2;
-  const matches = [];
-  do {
-    match2 = expression.exec(text);
-    if (match2) {
-      matches.push(match2);
-    }
-  } while (match2);
-  return matches;
-}
-function createRenderableContents(matches, text, linker) {
-  if (matches.length === 0) {
-    return [text];
-  }
-  const result = [];
-  let lastIndex = 0;
-  for (const match2 of matches) {
-    const index = match2.index;
-    const length = match2[0].length;
-    const capturedGroup = match2.slice(1).find((group) => group);
-    if (!capturedGroup) {
-      continue;
-    }
-    result.push(text.slice(lastIndex, index));
-    result.push(linker(capturedGroup));
-    lastIndex = index + length;
-  }
-  if (lastIndex < text.length) {
-    result.push(text.slice(lastIndex));
-  }
-  return result;
-}
-
-function isEmptyLine(content) {
-  return Object.keys(content).includes("__type") && content.__type === "empty-line";
-}
-function isCodeBlock(content) {
-  return Object.keys(content).includes("__type") && content.__type === "code-block";
-}
-function isInlineCode(content) {
-  return Object.keys(content).includes("__type") && content.__type === "inline-code";
-}
-
-var __defProp$g = Object.defineProperty;
-var __defProps$g = Object.defineProperties;
-var __getOwnPropDescs$g = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols$g = Object.getOwnPropertySymbols;
-var __hasOwnProp$g = Object.prototype.hasOwnProperty;
-var __propIsEnum$g = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$g = (obj, key, value) => key in obj ? __defProp$g(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues$g = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp$g.call(b, prop))
-      __defNormalProp$g(a, prop, b[prop]);
-  if (__getOwnPropSymbols$g)
-    for (var prop of __getOwnPropSymbols$g(b)) {
-      if (__propIsEnum$g.call(b, prop))
-        __defNormalProp$g(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps$g = (a, b) => __defProps$g(a, __getOwnPropDescs$g(b));
-function adaptDescribable(describable, linkGenerator) {
-  return {
-    description: describableToRenderableContent(describable, linkGenerator)
-  };
-}
-function describableToRenderableContent(describable, linkGenerator) {
-  if (!describable) {
-    return;
-  }
-  let content = [];
-  for (let i = 0; i < describable.length; i++) {
-    const line = describable[i];
-    const codeBlockMatch = line.match(/^```([a-zA-Z]*)$/);
-    if (codeBlockMatch) {
-      const language = codeBlockMatch[1] || "apex";
-      const codeBlockLines = [];
-      i++;
-      while (i < describable.length) {
-        const currentLine = describable[i];
-        if (currentLine.trim() === "```") {
-          break;
-        }
-        codeBlockLines.push(currentLine);
-        i++;
-      }
-      content = [
-        ...content,
-        {
-          __type: "code-block",
-          language,
-          content: codeBlockLines
-        },
-        { __type: "empty-line" }
-      ];
-      continue;
-    }
-    content = [
-      ...content,
-      ...replaceInlineReferences(line, linkGenerator),
-      {
-        __type: "empty-line"
-      }
-    ];
-  }
-  return content.filter((line, index, lines) => !(isEmptyLine(line) && index === lines.length - 1));
-}
-function adaptDocumentable(documentable, linkGenerator, subHeadingLevel) {
-  var _a, _b, _c;
-  function extractCustomTags(type) {
-    var _a2, _b2;
-    const baseTags = ["description", "group", "author", "date", "see", "example", "throws", "exception"];
-    return (_b2 = (_a2 = type.docComment) == null ? void 0 : _a2.annotations.filter((currentAnnotation) => !baseTags.includes(currentAnnotation.name.toLowerCase())).map((currentAnnotation) => __spreadProps$g(__spreadValues$g({}, adaptDescribable(currentAnnotation.bodyLines, linkGenerator)), {
-      name: currentAnnotation.name
-    }))) != null ? _b2 : [];
-  }
-  function extractAnnotationBody(type, annotationName) {
-    var _a2, _b2;
-    return (_b2 = (_a2 = type.docComment) == null ? void 0 : _a2.annotations.find(
-      (currentAnnotation) => currentAnnotation.name.toLowerCase() === annotationName
-    )) == null ? void 0 : _b2.body;
-  }
-  function extractSeeAnnotations(type) {
-    var _a2, _b2;
-    return (_b2 = (_a2 = type.docComment) == null ? void 0 : _a2.annotations.filter((currentAnnotation) => currentAnnotation.name.toLowerCase() === "see").map((currentAnnotation) => currentAnnotation.body)) != null ? _b2 : [];
-  }
-  return __spreadProps$g(__spreadValues$g({}, adaptDescribable((_a = documentable.docComment) == null ? void 0 : _a.descriptionLines, linkGenerator)), {
-    annotations: documentable.annotations.map((annotation) => annotation.type.toUpperCase()),
-    customTags: extractCustomTags(documentable),
-    example: {
-      headingLevel: subHeadingLevel,
-      heading: "Example",
-      value: describableToRenderableContent((_c = (_b = documentable.docComment) == null ? void 0 : _b.exampleAnnotation) == null ? void 0 : _c.bodyLines, linkGenerator)
-    },
-    group: extractAnnotationBody(documentable, "group"),
-    author: extractAnnotationBody(documentable, "author"),
-    date: extractAnnotationBody(documentable, "date"),
-    sees: extractSeeAnnotations(documentable).map(linkGenerator)
-  });
-}
-
-var __defProp$f = Object.defineProperty;
-var __defProps$f = Object.defineProperties;
-var __getOwnPropDescs$f = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols$f = Object.getOwnPropertySymbols;
-var __hasOwnProp$f = Object.prototype.hasOwnProperty;
-var __propIsEnum$f = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$f = (obj, key, value) => key in obj ? __defProp$f(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues$f = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp$f.call(b, prop))
-      __defNormalProp$f(a, prop, b[prop]);
-  if (__getOwnPropSymbols$f)
-    for (var prop of __getOwnPropSymbols$f(b)) {
-      if (__propIsEnum$f.call(b, prop))
-        __defNormalProp$f(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps$f = (a, b) => __defProps$f(a, __getOwnPropDescs$f(b));
-function adaptMethod(method, linkGenerator, baseHeadingLevel) {
-  var _a, _b, _c;
-  function buildTitle(method2) {
-    const { name, parameters } = method2;
-    const parametersString = parameters.map((param) => param.name).join(", ");
-    return `${name}(${parametersString})`;
-  }
-  function buildSignature(method2) {
-    const { access_modifier, typeReference, name, memberModifiers } = method2;
-    const parameters = method2.parameters.map((param) => `${param.typeReference.rawDeclaration} ${param.name}`).join(", ");
-    const members = memberModifiers.length > 0 ? `${memberModifiers.join(" ")} ` : "";
-    return {
-      __type: "code-block",
-      language: "apex",
-      content: [`${access_modifier} ${members}${typeReference.rawDeclaration} ${name}(${parameters})`]
-    };
-  }
-  return {
-    headingLevel: baseHeadingLevel,
-    doc: adaptDocumentable(method, linkGenerator, baseHeadingLevel + 1),
-    heading: buildTitle(method),
-    signature: {
-      headingLevel: baseHeadingLevel + 1,
-      heading: "Signature",
-      value: buildSignature(method)
-    },
-    returnType: {
-      headingLevel: baseHeadingLevel + 1,
-      heading: "Return Type",
-      value: __spreadProps$f(__spreadValues$f({}, adaptDescribable((_b = (_a = method.docComment) == null ? void 0 : _a.returnAnnotation) == null ? void 0 : _b.bodyLines, linkGenerator)), {
-        type: linkGenerator(method.typeReference.rawDeclaration)
-      })
-    },
-    throws: {
-      headingLevel: baseHeadingLevel + 1,
-      heading: "Throws",
-      value: (_c = method.docComment) == null ? void 0 : _c.throwsAnnotations.map((thrown) => mapThrows(thrown, linkGenerator))
-    },
-    parameters: {
-      headingLevel: baseHeadingLevel + 1,
-      heading: "Parameters",
-      value: method.parameters.map((param) => mapParameters(method, param, linkGenerator))
-    },
-    inherited: method.inherited
-  };
-}
-function adaptConstructor(typeName, constructor, linkGenerator, baseHeadingLevel) {
-  var _a;
-  function buildTitle(name, constructor2) {
-    const { parameters } = constructor2;
-    const parametersString = parameters.map((param) => param.name).join(", ");
-    return `${name}(${parametersString})`;
-  }
-  function buildSignature(name, constructor2) {
-    const { access_modifier } = constructor2;
-    const parameters = constructor2.parameters.map((param) => `${param.typeReference.rawDeclaration} ${param.name}`).join(", ");
-    return {
-      __type: "code-block",
-      language: "apex",
-      content: [`${access_modifier} ${name}(${parameters})`]
-    };
-  }
-  return {
-    doc: adaptDocumentable(constructor, linkGenerator, baseHeadingLevel + 1),
-    headingLevel: baseHeadingLevel,
-    heading: buildTitle(typeName, constructor),
-    signature: {
-      headingLevel: baseHeadingLevel + 1,
-      heading: "Signature",
-      value: buildSignature(typeName, constructor)
-    },
-    parameters: {
-      headingLevel: baseHeadingLevel + 1,
-      heading: "Parameters",
-      value: constructor.parameters.map((param) => mapParameters(constructor, param, linkGenerator))
-    },
-    throws: {
-      headingLevel: baseHeadingLevel + 1,
-      heading: "Throws",
-      value: (_a = constructor.docComment) == null ? void 0 : _a.throwsAnnotations.map((thrown) => mapThrows(thrown, linkGenerator))
-    }
-  };
-}
-function mapParameters(documentable, param, linkGenerator) {
-  var _a;
-  const paramAnnotation = (_a = documentable.docComment) == null ? void 0 : _a.paramAnnotations.find(
-    (pa) => pa.paramName.toLowerCase() === param.name.toLowerCase()
-  );
-  return __spreadProps$f(__spreadValues$f({}, adaptDescribable(paramAnnotation == null ? void 0 : paramAnnotation.bodyLines, linkGenerator)), {
-    name: param.name,
-    type: linkGenerator(param.typeReference.rawDeclaration)
-  });
-}
-function mapThrows(thrown, linkGenerator) {
-  return __spreadProps$f(__spreadValues$f({}, adaptDescribable(thrown.bodyLines, linkGenerator)), {
-    type: linkGenerator(thrown.exceptionName)
-  });
-}
-
-function adaptFieldOrProperty(field, linkGenerator, baseHeadingLevel) {
-  function buildSignature() {
-    const { access_modifier, name } = field;
-    const memberModifiers = field.memberModifiers.join(" ");
-    const codeContents = `${access_modifier} ${memberModifiers} ${name}`.replace(/ {2}/g, " ");
-    return {
-      __type: "code-block",
-      language: "apex",
-      content: [codeContents]
-    };
-  }
-  return {
-    headingLevel: baseHeadingLevel,
-    doc: adaptDocumentable(field, linkGenerator, baseHeadingLevel + 1),
-    heading: field.name,
-    type: {
-      headingLevel: baseHeadingLevel + 1,
-      heading: "Type",
-      value: linkGenerator(field.typeReference.rawDeclaration)
-    },
-    inherited: field.inherited,
-    accessModifier: field.access_modifier,
-    signature: {
-      headingLevel: baseHeadingLevel + 1,
-      heading: "Signature",
-      value: buildSignature()
-    }
-  };
-}
-
-var __defProp$e = Object.defineProperty;
-var __defProps$e = Object.defineProperties;
-var __getOwnPropDescs$e = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols$e = Object.getOwnPropertySymbols;
-var __hasOwnProp$e = Object.prototype.hasOwnProperty;
-var __propIsEnum$e = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$e = (obj, key, value) => key in obj ? __defProp$e(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues$e = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp$e.call(b, prop))
-      __defNormalProp$e(a, prop, b[prop]);
-  if (__getOwnPropSymbols$e)
-    for (var prop of __getOwnPropSymbols$e(b)) {
-      if (__propIsEnum$e.call(b, prop))
-        __defNormalProp$e(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps$e = (a, b) => __defProps$e(a, __getOwnPropDescs$e(b));
-function typeToRenderable(parsedFile, linkGenerator, config) {
-  function getRenderable() {
-    const { type } = parsedFile;
-    switch (type.type_name) {
-      case "enum":
-        return enumTypeToEnumSource(type, linkGenerator);
-      case "interface":
-        return interfaceTypeToInterfaceSource(type, linkGenerator);
-      case "class":
-        return classTypeToClassSource(type, linkGenerator);
-    }
-  }
-  return __spreadProps$e(__spreadValues$e({}, getRenderable()), {
-    filePath: parsedFile.source.filePath,
-    namespace: config.namespace
-  });
-}
-function baseTypeAdapter(type, linkGenerator, baseHeadingLevel) {
-  function getHeading(type2) {
-    const suffixMap = {
-      class: "Class",
-      interface: "Interface",
-      enum: "Enum"
-    };
-    return `${type2.name} ${suffixMap[type2.type_name]}`;
-  }
-  return {
-    headingLevel: baseHeadingLevel,
-    heading: getHeading(type),
-    doc: adaptDocumentable(type, linkGenerator, baseHeadingLevel + 1),
-    name: type.name,
-    meta: {
-      accessModifier: type.access_modifier
-    }
-  };
-}
-function enumTypeToEnumSource(enumType, linkGenerator, baseHeadingLevel = 1) {
-  return __spreadProps$e(__spreadValues$e({
-    type: "enum"
-  }, baseTypeAdapter(enumType, linkGenerator, baseHeadingLevel)), {
-    values: {
-      headingLevel: baseHeadingLevel + 1,
-      heading: "Values",
-      value: enumType.values.map((value) => {
-        var _a;
-        return __spreadProps$e(__spreadValues$e({}, adaptDescribable((_a = value.docComment) == null ? void 0 : _a.descriptionLines, linkGenerator)), {
-          value: value.name
-        });
-      })
-    }
-  });
-}
-function interfaceTypeToInterfaceSource(interfaceType, linkGenerator, baseHeadingLevel = 1) {
-  return __spreadProps$e(__spreadValues$e({
-    type: "interface"
-  }, baseTypeAdapter(interfaceType, linkGenerator, baseHeadingLevel)), {
-    extends: interfaceType.extended_interfaces.map(linkGenerator),
-    methods: {
-      headingLevel: baseHeadingLevel + 1,
-      heading: "Methods",
-      value: interfaceType.methods.map((method) => adaptMethod(method, linkGenerator, baseHeadingLevel + 2))
-    }
-  });
-}
-function classTypeToClassSource(classType, linkGenerator, baseHeadingLevel = 1) {
-  return __spreadProps$e(__spreadValues$e({
-    type: "class"
-  }, baseTypeAdapter(classType, linkGenerator, baseHeadingLevel)), {
-    classModifier: classType.classModifier,
-    sharingModifier: classType.sharingModifier,
-    implements: classType.implemented_interfaces.map(linkGenerator),
-    extends: classType.inheritanceChain.map(linkGenerator),
-    methods: adaptMembers("Methods", classType.methods, adaptMethod, linkGenerator, baseHeadingLevel + 1),
-    constructors: adaptMembers(
-      "Constructors",
-      classType.constructors,
-      (constructor, linkGenerator2, baseHeadingLevel2) => adaptConstructor(classType.name, constructor, linkGenerator2, baseHeadingLevel2),
-      linkGenerator,
-      baseHeadingLevel + 1
-    ),
-    fields: adaptMembers(
-      "Fields",
-      classType.fields,
-      adaptFieldOrProperty,
-      linkGenerator,
-      baseHeadingLevel + 1
-    ),
-    properties: adaptMembers(
-      "Properties",
-      classType.properties,
-      adaptFieldOrProperty,
-      linkGenerator,
-      baseHeadingLevel + 1
-    ),
-    innerClasses: {
-      headingLevel: baseHeadingLevel + 1,
-      heading: "Classes",
-      value: classType.classes.map(
-        (innerClass) => classTypeToClassSource(__spreadProps$e(__spreadValues$e({}, innerClass), { inheritanceChain: [] }), linkGenerator, baseHeadingLevel + 2)
-      )
-    },
-    innerEnums: {
-      headingLevel: baseHeadingLevel + 1,
-      heading: "Enums",
-      value: classType.enums.map((innerEnum) => enumTypeToEnumSource(innerEnum, linkGenerator, baseHeadingLevel + 2))
-    },
-    innerInterfaces: {
-      headingLevel: baseHeadingLevel + 1,
-      heading: "Interfaces",
-      value: classType.interfaces.map(
-        (innerInterface) => interfaceTypeToInterfaceSource(innerInterface, linkGenerator, baseHeadingLevel + 2)
-      )
-    }
-  });
-}
-function adaptMembers(heading, members, adapter, linkFromTypeNameGenerator, headingLevel) {
-  return {
-    headingLevel,
-    heading,
-    isGrouped: hasGroup(members),
-    value: hasGroup(members) ? toGroupedMembers(members, adapter, linkFromTypeNameGenerator, headingLevel + 1) : toFlat(members, adapter, linkFromTypeNameGenerator, headingLevel + 1)
-  };
-}
-function hasGroup(members) {
-  return members.some((member) => member.group);
-}
-function toFlat(members, adapter, linkGenerator, baseHeadingLevel) {
-  return members.map((member) => adapter(member, linkGenerator, baseHeadingLevel));
-}
-function toGroupedMembers(members, adapter, linkGenerator, baseHeadingLevel) {
-  const groupedMembers = groupByGroupName(members);
-  return Object.entries(groupedMembers).map(
-    ([groupName, members2]) => singleGroup(baseHeadingLevel, groupName, adapter, members2, linkGenerator)
-  );
-}
-function groupByGroupName(members) {
-  return members.reduce(
-    (acc, member) => {
-      var _a, _b;
-      const groupName = (_a = member.group) != null ? _a : "Other";
-      acc[groupName] = (_b = acc[groupName]) != null ? _b : [];
-      acc[groupName].push(member);
-      return acc;
-    },
-    {}
-  );
-}
-function singleGroup(headingLevel, groupName, adapter, members, linkGenerator) {
-  return {
-    headingLevel,
-    heading: groupName,
-    groupDescription: members[0].groupDescription,
-    // All fields in the group have the same description
-    value: toFlat(members, adapter, linkGenerator, headingLevel + 1)
-  };
-}
-
-const generateLink = (strategy) => {
-  switch (strategy) {
-    case "relative":
-      return generateRelativeLink;
-    case "no-link":
-      return generateNoLink;
-    case "none":
-      return returnReferenceAsIs;
-  }
-};
-const generateRelativeLink = (references, from, referenceName) => {
-  function getRelativePath(fromPath, toPath) {
-    return path.relative(path.parse(path.join("/", fromPath)).dir, path.join("/", toPath));
-  }
-  const referenceTo = references[referenceName];
-  if (!referenceTo) {
-    return referenceName;
-  }
-  if (referenceTo && from === "__base__") {
-    return {
-      __type: "link",
-      title: referenceTo.displayName,
-      url: getRelativePath("", referenceTo.referencePath)
-    };
-  }
-  const referenceFrom = references[from];
-  if (!referenceFrom) {
-    return referenceTo.displayName;
-  }
-  return {
-    __type: "link",
-    title: referenceTo.displayName,
-    url: getRelativePath(referenceFrom.referencePath, referenceTo.referencePath)
-  };
-};
-const generateNoLink = (references, _from, referenceName) => {
-  const referenceTo = references[referenceName];
-  return referenceTo ? referenceTo.displayName : referenceName;
-};
-const returnReferenceAsIs = (references, _from, referenceName) => {
-  const referenceTo = references[referenceName];
-  if (!referenceTo) {
-    return referenceName;
-  }
-  return {
-    __type: "link",
-    title: referenceTo.displayName,
-    url: referenceTo.referencePath
-  };
-};
-
-function parsedFilesToRenderableBundle(config, parsedFiles, references) {
-  const referenceFinder = apply(generateLink(config.linkingStrategy), references);
-  function toReferenceGuide(parsedFiles2) {
-    return parsedFiles2.reduce(
-      addToReferenceGuide(apply(referenceFinder, "__base__"), config, references),
-      {}
-    );
-  }
-  function toRenderables(parsedFiles2) {
-    return parsedFiles2.reduce((acc, parsedFile) => {
-      const renderable = typeToRenderable(parsedFile, apply(referenceFinder, parsedFile.source.name), config);
-      acc.push(renderable);
-      return acc;
-    }, []);
-  }
-  return {
-    referencesByGroup: toReferenceGuide(parsedFiles),
-    renderables: toRenderables(parsedFiles)
-  };
-}
-function addToReferenceGuide(findLinkFromHome, config, references) {
-  return (acc, parsedFile) => {
-    var _a, _b;
-    const group = getTypeGroup$1(parsedFile.type, config);
-    if (!acc[group]) {
-      acc[group] = [];
-    }
-    acc[group].push({
-      reference: references[parsedFile.type.name],
-      title: findLinkFromHome(parsedFile.type.name),
-      description: (_b = adaptDescribable((_a = parsedFile.type.docComment) == null ? void 0 : _a.descriptionLines, findLinkFromHome).description) != null ? _b : null
-    });
-    return acc;
-  };
-}
-function getTypeGroup$1(type, config) {
-  var _a, _b;
-  const groupAnnotation = (_a = type.docComment) == null ? void 0 : _a.annotations.find((annotation) => annotation.name.toLowerCase() === "group");
-  return (_b = groupAnnotation == null ? void 0 : groupAnnotation.body) != null ? _b : config.defaultGroupName;
-}
-
-function parseApexMetadata(input) {
-  return _function.pipe(input, parse, E__namespace.map(toMap));
-}
-function parse(input) {
-  return E__namespace.tryCatch(() => new fastXmlParser.XMLParser().parse(input), E__namespace.toError);
-}
-function toMap(metadata) {
-  const map = /* @__PURE__ */ new Map();
-  map.set("apiVersion", String(metadata.ApexClass.apiVersion));
-  if (metadata.ApexClass.status) {
-    map.set("status", String(metadata.ApexClass.status));
-  }
-  return map;
-}
-
-var __defProp$d = Object.defineProperty;
-var __defProps$d = Object.defineProperties;
-var __getOwnPropDescs$d = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols$d = Object.getOwnPropertySymbols;
-var __hasOwnProp$d = Object.prototype.hasOwnProperty;
-var __propIsEnum$d = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$d = (obj, key, value) => key in obj ? __defProp$d(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues$d = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp$d.call(b, prop))
-      __defNormalProp$d(a, prop, b[prop]);
-  if (__getOwnPropSymbols$d)
-    for (var prop of __getOwnPropSymbols$d(b)) {
-      if (__propIsEnum$d.call(b, prop))
-        __defNormalProp$d(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps$d = (a, b) => __defProps$d(a, __getOwnPropDescs$d(b));
-var __async$6 = (__this, __arguments, generator) => {
-  return new Promise((resolve, reject) => {
-    var fulfilled = (value) => {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var rejected = (value) => {
-      try {
-        step(generator.throw(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
-    step((generator = generator.apply(__this, __arguments)).next());
-  });
-};
-class ReflectionErrors {
-  constructor(errors) {
-    this.errors = errors;
-    this._tag = "ReflectionErrors";
-  }
-}
-class ReflectionError {
-  constructor(file, message) {
-    this.file = file;
-    this.message = message;
-  }
-}
-function reflectAsync(rawSource) {
-  return __async$6(this, null, function* () {
-    return new Promise((resolve, reject) => {
-      const result = apexReflection.reflect(rawSource);
-      if (result.typeMirror) {
-        return resolve(result.typeMirror);
-      } else if (result.error) {
-        return reject(result.error);
-      } else {
-        return reject(new Error("Unknown error"));
-      }
-    });
-  });
-}
-function reflectBundles(apexBundles) {
-  const semiGroupReflectionError = {
-    concat: (x, y) => new ReflectionErrors([...x.errors, ...y.errors])
-  };
-  const Ap = TE__namespace.getApplicativeTaskValidation(T__namespace.ApplyPar, semiGroupReflectionError);
-  return _function.pipe(apexBundles, A__namespace.traverse(Ap)(reflectBundle));
-}
-function reflectBundle(apexBundle) {
-  const convertToParsedFile = apply(toParsedFile, apexBundle.filePath);
-  const withMetadata = apply(addMetadata, apexBundle.metadataContent);
-  return _function.pipe(apexBundle, reflectAsTask, TE__namespace.map(convertToParsedFile), TE__namespace.flatMap(withMetadata));
-}
-function reflectAsTask(apexBundle) {
-  return TE__namespace.tryCatch(
-    () => reflectAsync(apexBundle.content),
-    (error) => new ReflectionErrors([new ReflectionError(apexBundle.filePath, error.message)])
-  );
-}
-function toParsedFile(filePath, typeMirror) {
-  return {
-    source: {
-      filePath,
-      name: typeMirror.name,
-      type: typeMirror.type_name
-    },
-    type: typeMirror
-  };
-}
-function addMetadata(rawMetadataContent, parsedFile) {
-  return TE__namespace.fromEither(
-    _function.pipe(
-      parsedFile.type,
-      (type) => addFileMetadataToTypeAnnotation(type, rawMetadataContent),
-      E__namespace.map((type) => __spreadProps$d(__spreadValues$d({}, parsedFile), { type })),
-      E__namespace.mapLeft((error) => errorToReflectionErrors(error, parsedFile.source.filePath))
-    )
-  );
-}
-function errorToReflectionErrors(error, filePath) {
-  return new ReflectionErrors([new ReflectionError(filePath, error.message)]);
-}
-function addFileMetadataToTypeAnnotation(type, metadata) {
-  const concatAnnotationToType = apply(concatAnnotations, type);
-  return _function.pipe(
-    O__namespace.fromNullable(metadata),
-    O__namespace.map(concatAnnotationToType),
-    O__namespace.getOrElse(() => E__namespace.right(type))
-  );
-}
-function concatAnnotations(type, metadataInput) {
-  return _function.pipe(
-    metadataInput,
-    parseApexMetadata,
-    E__namespace.map((metadataMap) => __spreadProps$d(__spreadValues$d({}, type), {
-      annotations: [...type.annotations, ...mapToAnnotations(metadataMap)]
-    }))
-  );
-}
-function mapToAnnotations(metadata) {
-  return Array.from(metadata.entries()).map(([key, value]) => {
-    const declaration = `${key}: ${value}`;
-    return {
-      name: declaration,
-      type: declaration,
-      rawDeclaration: declaration
-    };
-  });
-}
-
-function createInheritanceChain(repository, classMirror) {
-  return _function.pipe(
-    O__namespace.fromNullable(classMirror.extended_class),
-    O__namespace.match(
-      () => [],
-      (extendedClassName) => inheritanceChainFromParentClassName(repository, extendedClassName)
-    )
-  );
-}
-function inheritanceChainFromParentClassName(repository, className) {
-  return _function.pipe(
-    O__namespace.fromNullable(repository.find((type) => type.name.toLowerCase() === className.toLowerCase())),
-    O__namespace.match(
-      () => [className],
-      (extendedClass) => [className, ...createInheritanceChain(repository, extendedClass)]
-    )
-  );
-}
-
-const parsedFilesToTypes = (parsedFiles) => parsedFiles.map((parsedFile) => parsedFile.type);
-
-var __defProp$c = Object.defineProperty;
-var __defProps$c = Object.defineProperties;
-var __getOwnPropDescs$c = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols$c = Object.getOwnPropertySymbols;
-var __hasOwnProp$c = Object.prototype.hasOwnProperty;
-var __propIsEnum$c = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$c = (obj, key, value) => key in obj ? __defProp$c(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues$c = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp$c.call(b, prop))
-      __defNormalProp$c(a, prop, b[prop]);
-  if (__getOwnPropSymbols$c)
-    for (var prop of __getOwnPropSymbols$c(b)) {
-      if (__propIsEnum$c.call(b, prop))
-        __defNormalProp$c(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps$c = (a, b) => __defProps$c(a, __getOwnPropDescs$c(b));
-const addInheritanceChainToTypes = (parsedFiles) => parsedFiles.map((parsedFile) => __spreadProps$c(__spreadValues$c({}, parsedFile), {
-  type: addInheritanceChain(parsedFile.type, parsedFilesToTypes(parsedFiles))
-}));
-function addInheritanceChain(current, repository) {
-  if (current.type_name === "enum" || current.type_name === "interface") {
-    return current;
-  } else {
-    const inheritanceChain = createInheritanceChain(repository, current);
-    return __spreadProps$c(__spreadValues$c({}, current), {
-      inheritanceChain
-    });
-  }
-}
-
-var __defProp$b = Object.defineProperty;
-var __defProps$b = Object.defineProperties;
-var __getOwnPropDescs$b = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols$b = Object.getOwnPropertySymbols;
-var __hasOwnProp$b = Object.prototype.hasOwnProperty;
-var __propIsEnum$b = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$b = (obj, key, value) => key in obj ? __defProp$b(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues$b = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp$b.call(b, prop))
-      __defNormalProp$b(a, prop, b[prop]);
-  if (__getOwnPropSymbols$b)
-    for (var prop of __getOwnPropSymbols$b(b)) {
-      if (__propIsEnum$b.call(b, prop))
-        __defNormalProp$b(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps$b = (a, b) => __defProps$b(a, __getOwnPropDescs$b(b));
-const addInheritedMembersToTypes = (parsedFiles) => parsedFiles.map((parsedFile) => addInheritedMembers(parsedFilesToTypes(parsedFiles), parsedFile));
-function addInheritedMembers(repository, parsedFile) {
-  function addInheritedMembersToType(repository2, current) {
-    if (current.type_name === "enum") {
-      return current;
-    } else if (current.type_name === "interface") {
-      return addInheritedInterfaceMethods(current, repository2);
-    } else {
-      return addInheritedClassMembers(current, repository2);
-    }
-  }
-  return __spreadProps$b(__spreadValues$b({}, parsedFile), {
-    type: addInheritedMembersToType(repository, parsedFile.type)
-  });
-}
-function addInheritedInterfaceMethods(interfaceMirror, repository) {
-  function methodAlreadyExists(memberName, members) {
-    return members.some((member) => member.name.toLowerCase() === memberName.toLowerCase());
-  }
-  function parentExtractor(interfaceMirror2) {
-    return interfaceMirror2.extended_interfaces;
-  }
-  const parents = getParents(parentExtractor, interfaceMirror, repository);
-  return __spreadProps$b(__spreadValues$b({}, interfaceMirror), {
-    methods: parents.reduce(
-      (acc, currentValue) => [
-        ...acc,
-        ...currentValue.methods.filter((method) => !methodAlreadyExists(method.name, acc)).map((method) => __spreadProps$b(__spreadValues$b({}, method), {
-          inherited: true
-        }))
-      ],
-      interfaceMirror.methods
-    )
-  });
-}
-function addInheritedClassMembers(classMirror, repository) {
-  function memberAlreadyExists(memberName, members) {
-    return members.some((member) => member.name.toLowerCase() === memberName.toLowerCase());
-  }
-  function parentExtractor(classMirror2) {
-    return classMirror2.extended_class ? [classMirror2.extended_class] : [];
-  }
-  function filterMember(members, existing) {
-    return members.filter((member) => member.access_modifier.toLowerCase() !== "private").filter((member) => !memberAlreadyExists(member.name, existing)).map((member) => __spreadProps$b(__spreadValues$b({}, member), {
-      inherited: true
-    }));
-  }
-  const parents = getParents(parentExtractor, classMirror, repository);
-  return __spreadProps$b(__spreadValues$b({}, classMirror), {
-    fields: parents.reduce(
-      (acc, currentValue) => [...acc, ...filterMember(currentValue.fields, acc)],
-      classMirror.fields
-    ),
-    properties: parents.reduce(
-      (acc, currentValue) => [...acc, ...filterMember(currentValue.properties, acc)],
-      classMirror.properties
-    ),
-    methods: parents.reduce(
-      (acc, currentValue) => [...acc, ...filterMember(currentValue.methods, acc)],
-      classMirror.methods
-    )
-  });
-}
-function getParents(extendedNamesExtractor, current, repository) {
-  return _function.pipe(
-    extendedNamesExtractor(current),
-    (interfaces) => interfaces.map((interfaceName) => repository.find((type) => type.name === interfaceName)),
-    (interfaces = []) => interfaces.filter((type) => type !== void 0),
-    (interfaces) => interfaces.reduce(
-      (acc, current2) => [...acc, ...getParents(extendedNamesExtractor, current2, repository)],
-      interfaces
-    )
-  );
-}
-
-const typeDocPartial = `
-{{#> documentablePartialTemplate}}
-
-{{#if doc.group}}
-**Group** {{doc.group}}
-{{/if}}
-
-{{#if doc.author}}
-**Author** {{doc.author}}
-{{/if}}
-
-{{#if doc.date}}
-**Date** {{doc.date}}
-{{/if}}
-
-{{#each doc.sees}}
-**See** {{link this}}
-
-{{/each}}
-
-{{#if namespace}}
-## Namespace
-{{namespace}}
-{{/if}}
-
-{{/documentablePartialTemplate}}
-`.trim();
-
-const documentablePartialTemplate = `
-{{#each doc.annotations}}
-\`{{this}}\`
-{{/each}}
-
-{{{renderContent doc.description}}}
-
-{{#each doc.customTags}}
-**{{splitAndCapitalize name}}** 
-
-{{{renderContent description}}}
-
-{{/each}}
-
-{{> @partial-block}}
-
-{{#if doc.mermaid.value}}
-{{ heading doc.mermaid.headingLevel doc.mermaid.heading }}
-{{code doc.mermaid.value}}
-{{/if}}
-
-{{#if doc.example.value}}
-{{ heading doc.example.headingLevel doc.example.heading }}
-{{{renderContent doc.example.value}}}
-{{/if}}
-`.trim();
-
-const methodsPartialTemplate = `
-{{ heading headingLevel heading }}
-{{#each value}}
-{{{ heading headingLevel (inlineCode heading) }}}
-
-{{#if inherited}}
-*Inherited*
-{{/if}}
-
-{{#> documentablePartialTemplate}}
-
-{{ heading signature.headingLevel signature.heading }}
-{{ code signature.value }}
-
-{{#if parameters.value}}
-{{ heading parameters.headingLevel parameters.heading }}
-| Name | Type | Description |
-|------|------|-------------|
-{{#each parameters.value}}
-| {{name}} | {{link type}} | {{{renderContent description}}} |
-{{/each}}
-{{/if}}
-
-{{ heading returnType.headingLevel returnType.heading }}
-**{{link returnType.value.type}}**
-
-{{#if returnType.value.description}}
-{{returnType.value.description}}
-{{/if}}
-
-{{#if throws.value}}
-{{ heading throws.headingLevel throws.heading }}
-{{#each throws.value}}
-{{link this.type}}: {{this.description}}
-
-{{/each}}
-{{/if}}
-{{/documentablePartialTemplate}}
-
-{{#unless @last}}---{{/unless}}
-
-{{/each}}
-`.trim();
-
-const groupedMembersPartialTemplate = `
-{{ heading headingLevel heading }}
-{{#each value}}
-{{> (lookup .. "subTemplate") this}}
-{{/each}}
-`.trim();
-
-const constructorsPartialTemplate = `
-{{ heading headingLevel heading }}
-{{#each value}}
-{{{ heading headingLevel (inlineCode heading) }}}
-
-{{#> documentablePartialTemplate}}
-
-{{ heading signature.headingLevel signature.heading }}
-{{ code signature.value }}
-
-{{#if parameters.value}}
-{{ heading parameters.headingLevel parameters.heading }}
-| Name | Type | Description |
-|------|------|-------------|
-{{#each parameters.value}}
-| {{name}} | {{link type}} | {{description}} |
-{{/each}}
-{{/if}}
-
-{{#if throws.value}}
-{{ heading throws.headingLevel throws.heading }}
-{{#each throws.value}}
-{{link this.type}}: {{this.description}}
-
-{{/each}}
-{{/if}}
-{{/documentablePartialTemplate}}
-
-{{#unless @last}}---{{/unless}}
-
-{{/each}}
-`.trim();
-
-const fieldsPartialTemplate = `
-{{ heading headingLevel heading }}
-{{#each value}}
-{{{ heading headingLevel (inlineCode heading) }}}
-
-{{#if inherited}}
-*Inherited*
-{{/if}}
-
-{{#> documentablePartialTemplate }}
-
-{{ heading signature.headingLevel signature.heading }}
-{{ code signature.value }}
-
-{{ heading type.headingLevel type.heading }}
-{{link type.value}}
-
-{{/documentablePartialTemplate}}
-
-{{#unless @last}}---{{/unless}}
-
-{{/each}}
-`.trim();
-
-const classMarkdownTemplate = `
-{{ heading headingLevel heading }}
-{{#if classModifier}}
-\`{{classModifier}}\`
-{{/if}}
-
-{{> typeDocumentation}}
-
-{{#if extends.length}}
-**Inheritance**
-
-{{#each extends}}{{link this}}{{#unless @last}} < {{/unless}}{{/each}}
-{{/if}}
-
-{{#if implements}}
-**Implements**
-
-{{#each implements}}
-{{link this}}{{#unless @last}}, {{/unless}}
-{{/each}}
-{{/if}}
-
-{{#if fields.value}}
-{{#if fields.isGrouped}}
-{{> groupedMembersPartialTemplate fields subTemplate="fieldsPartialTemplate"}}
-{{else}}
-{{> fieldsPartialTemplate fields}}
-{{/if}}
-{{/if}}
-
-{{#if properties.value}}
-{{#if properties.isGrouped}}
-{{> groupedMembersPartialTemplate properties subTemplate="fieldsPartialTemplate"}}
-{{else}}
-{{> fieldsPartialTemplate properties}}
-{{/if}}
-{{/if}}
-
-{{#if constructors.value}}
-{{#if constructors.isGrouped}}
-{{> groupedMembersPartialTemplate constructors subTemplate="constructorsPartialTemplate"}}
-{{else}}
-{{> constructorsPartialTemplate constructors}}
-{{/if}}
-{{/if}}
-
-{{#if methods.value}}
-{{#if methods.isGrouped}}
-{{> groupedMembersPartialTemplate methods subTemplate="methodsPartialTemplate"}}
-{{else}}
-{{> methodsPartialTemplate methods}}
-{{/if}}
-{{/if}}
-
-{{#if innerClasses.value}}
-{{ heading innerClasses.headingLevel innerClasses.heading }}
-{{#each innerClasses.value}}
-{{> classTemplate this}}
-{{/each}}
-{{/if}}
-
-{{#if innerEnums.value}}
-{{ heading innerEnums.headingLevel innerEnums.heading }}
-{{#each innerEnums.value}}
-{{> enumTemplate this}}
-{{/each}}
-{{/if}}
-
-{{#if innerInterfaces.value}}
-{{ heading innerInterfaces.headingLevel innerInterfaces.heading }}
-{{#each innerInterfaces.value}}
-{{> interfaceTemplate this}}
-{{/each}}
-{{/if}}
-`.trim();
-
-const enumMarkdownTemplate = `
-{{ heading headingLevel heading }}
-
-{{> typeDocumentation }}
-
-{{ heading values.headingLevel values.heading }}
-| Value | Description |
-|-------|-------------|
-{{#each values.value}}
-| {{value}} | {{description}} |
-{{/each}}
-`.trim();
-
-const interfaceMarkdownTemplate = `
-{{ heading headingLevel heading }}
-
-{{> typeDocumentation }}
-
-{{#if extends}}
-**Extends**
-{{#each extends}}
-{{link this}}{{#unless @last}}, {{/unless}}
-{{/each}}
-{{/if}}
-
-{{#if methods}}
-{{> methodsPartialTemplate methods}}
-{{/if}}
-`.trim();
-
-class Template {
-  constructor() {
-    Handlebars.registerPartial("typeDocumentation", typeDocPartial);
-    Handlebars.registerPartial("documentablePartialTemplate", documentablePartialTemplate);
-    Handlebars.registerPartial("methodsPartialTemplate", methodsPartialTemplate);
-    Handlebars.registerPartial("constructorsPartialTemplate", constructorsPartialTemplate);
-    Handlebars.registerPartial("groupedMembersPartialTemplate", groupedMembersPartialTemplate);
-    Handlebars.registerPartial("fieldsPartialTemplate", fieldsPartialTemplate);
-    Handlebars.registerPartial("classTemplate", classMarkdownTemplate);
-    Handlebars.registerPartial("enumTemplate", enumMarkdownTemplate);
-    Handlebars.registerPartial("interfaceTemplate", interfaceMarkdownTemplate);
-    Handlebars.registerHelper("link", link);
-    Handlebars.registerHelper("code", convertCodeBlock);
-    Handlebars.registerHelper("renderContent", resolveRenderableContent);
-    Handlebars.registerHelper("heading", heading);
-    Handlebars.registerHelper("inlineCode", inlineCode);
-    Handlebars.registerHelper("splitAndCapitalize", splitAndCapitalize);
-  }
-  static getInstance() {
-    if (!Template.instance) {
-      Template.instance = new Template();
-    }
-    return Template.instance;
-  }
-  compile(request) {
-    const compiled = Handlebars.compile(request.template);
-    return compiled(request.source).trim().replace(/\n{3,}/g, "\n\n");
-  }
-}
-const splitAndCapitalize = (text) => {
-  const words = text.split(/[-_]+/);
-  const capitalizedWords = [];
-  for (const word of words) {
-    capitalizedWords.push(word.charAt(0).toUpperCase() + word.slice(1));
-  }
-  return capitalizedWords.join(" ");
-};
-const heading = (level, text) => {
-  return `${"#".repeat(level)} ${text}`;
-};
-const inlineCode = (text) => {
-  return new Handlebars.SafeString(`\`${text}\``);
-};
-const convertCodeBlock = (codeBlock) => {
-  return new Handlebars.SafeString(
-    `
-\`\`\`${codeBlock.language}
-${codeBlock.content.join("\n")}
-\`\`\`
-  `.trim()
-  );
-};
-const resolveRenderableContent = (description) => {
-  if (!description) {
-    return "";
-  }
-  function reduceDescription(acc, curr) {
-    if (isEmptyLine(curr)) {
-      return acc + "\n";
-    }
-    if (isCodeBlock(curr)) {
-      return acc + convertCodeBlock(curr) + "\n";
-    }
-    if (isInlineCode(curr)) {
-      return acc + inlineCode(curr.content).toString() + " ";
-    } else {
-      return acc + Handlebars.escapeExpression(link(curr)).trim() + " ";
-    }
-  }
-  return description.reduce(reduceDescription, "").trim();
-};
-const link = (source) => {
-  if (typeof source === "string") {
-    return source;
-  } else {
-    return `[${source.title}](${source.url})`;
-  }
-};
-
-const convertToDocumentationBundle = (referenceGuideTemplate, { referencesByGroup, renderables }) => ({
-  referenceGuide: {
-    frontmatter: null,
-    content: referencesToReferenceGuideContent(referencesByGroup, referenceGuideTemplate),
-    outputDocPath: "index.md"
-  },
-  docs: renderables.map(
-    (renderable) => renderableToPageData(Object.values(referencesByGroup).flat(), renderable)
-  )
-});
-function referencesToReferenceGuideContent(references, template) {
-  function alphabetizeReferences(references2) {
-    return Object.keys(references2).sort((a, b) => a.localeCompare(b)).reduce((acc, key) => {
-      acc[key] = references2[key].sort((a, b) => a.title.toString().localeCompare(b.title.toString()));
-      return acc;
-    }, {});
-  }
-  return _function.pipe(
-    references,
-    alphabetizeReferences,
-    (references2) => compile({
-      template,
-      source: references2
-    })
-  );
-}
-function renderableToPageData(referenceGuideReference, renderable) {
-  function buildDocOutput(renderable2, docContents) {
-    var _a;
-    const reference = referenceGuideReference.find(
-      (ref) => ref.reference.source.name.toLowerCase() === renderable2.name.toLowerCase()
-    );
-    return {
-      source: {
-        filePath: renderable2.filePath,
-        name: renderable2.name,
-        type: renderable2.type
-      },
-      outputDocPath: reference.reference.outputDocPath,
-      frontmatter: null,
-      content: docContents,
-      group: (_a = renderable2.doc.group) != null ? _a : defaults.defaults.defaultGroupName
-    };
-  }
-  return _function.pipe(renderable, resolveApexTypeTemplate, compile, (docContents) => buildDocOutput(renderable, docContents));
-}
-function resolveApexTypeTemplate(renderable) {
-  function getTemplate(renderable2) {
-    switch (renderable2.type) {
-      case "enum":
-        return enumMarkdownTemplate;
-      case "interface":
-        return interfaceMarkdownTemplate;
-      case "class":
-        return classMarkdownTemplate;
-    }
-  }
-  return {
-    template: getTemplate(renderable),
-    source: renderable
-  };
-}
-function compile(request) {
-  return Template.getInstance().compile(request);
-}
-
-var __defProp$a = Object.defineProperty;
-var __defProps$a = Object.defineProperties;
-var __getOwnPropDescs$a = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols$a = Object.getOwnPropertySymbols;
-var __hasOwnProp$a = Object.prototype.hasOwnProperty;
-var __propIsEnum$a = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$a = (obj, key, value) => key in obj ? __defProp$a(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues$a = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp$a.call(b, prop))
-      __defNormalProp$a(a, prop, b[prop]);
-  if (__getOwnPropSymbols$a)
-    for (var prop of __getOwnPropSymbols$a(b)) {
-      if (__propIsEnum$a.call(b, prop))
-        __defNormalProp$a(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps$a = (a, b) => __defProps$a(a, __getOwnPropDescs$a(b));
-class Manifest {
-  /**
-   * Constructs a new Manifest object.
-   * @param types List of types to be wrapped by this object.
-   * @param isForInnerTypes Whether this manifest represent an inner type or not.
-   */
-  constructor(types, isForInnerTypes = false) {
-    this.types = types;
-    this.isForInnerTypes = isForInnerTypes;
-  }
-  filteredByAccessModifierAndAnnotations(modifiers) {
-    const filteredTypes = Manifest.filterAccessibleModifier(this.types, modifiers);
-    const typesToReturn = [];
-    for (const filteredType of filteredTypes) {
-      typesToReturn.push(Manifest.filterSingleType(filteredType, modifiers, this.isForInnerTypes));
-    }
-    return typesToReturn;
-  }
-  static filterSingleType(currentType, modifiers, isForInnerTypes) {
-    if (currentType.type_name === "enum") {
-      return currentType;
-    }
-    if (currentType.type_name === "interface") {
-      const currentInterface = currentType;
-      return __spreadProps$a(__spreadValues$a({}, currentType), {
-        methods: this.filterAccessibleModifier(currentInterface.methods, modifiers)
-      });
-    }
-    const currentClass = currentType;
-    const filteredClass = __spreadProps$a(__spreadValues$a({}, currentType), {
-      methods: this.filterAccessibleModifier(currentClass.methods, modifiers),
-      properties: this.filterAccessibleModifier(currentClass.properties, modifiers),
-      fields: this.filterAccessibleModifier(currentClass.fields, modifiers),
-      constructors: this.filterAccessibleModifier(currentClass.constructors, modifiers)
-    });
-    if (!isForInnerTypes) {
-      return __spreadProps$a(__spreadValues$a({}, filteredClass), {
-        enums: this.filterAccessibleModifier(currentClass.enums, modifiers),
-        interfaces: this.filterAccessibleModifier(currentClass.interfaces, modifiers),
-        classes: new Manifest(currentClass.classes, true).filteredByAccessModifierAndAnnotations(
-          modifiers
-        )
-      });
-    }
-    return filteredClass;
-  }
-  static filterAccessibleModifier(accessAndDocAware, modifiers) {
-    return accessAndDocAware.filter((type) => this.shouldFilterType(type, modifiers));
-  }
-  static shouldFilterType(accessAndDocAware, modifiers) {
-    var _a;
-    const hasIgnoreDocAnnotation = (_a = accessAndDocAware.docComment) == null ? void 0 : _a.annotations.some(
-      (annotation) => annotation.name.toLowerCase() === "ignore"
-    );
-    if (hasIgnoreDocAnnotation) {
-      return false;
-    }
-    return modifiers.includes(accessAndDocAware.access_modifier) || accessAndDocAware.annotations.some((annotation) => modifiers.includes(annotation.type.toLowerCase()));
-  }
-}
-
-var __defProp$9 = Object.defineProperty;
-var __defProps$9 = Object.defineProperties;
-var __getOwnPropDescs$9 = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols$9 = Object.getOwnPropertySymbols;
-var __hasOwnProp$9 = Object.prototype.hasOwnProperty;
-var __propIsEnum$9 = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$9 = (obj, key, value) => key in obj ? __defProp$9(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues$9 = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp$9.call(b, prop))
-      __defNormalProp$9(a, prop, b[prop]);
-  if (__getOwnPropSymbols$9)
-    for (var prop of __getOwnPropSymbols$9(b)) {
-      if (__propIsEnum$9.call(b, prop))
-        __defNormalProp$9(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps$9 = (a, b) => __defProps$9(a, __getOwnPropDescs$9(b));
-function filterScope(scopes, parsedFiles) {
-  return parsedFiles.filter(({ type }) => Manifest.shouldFilterType(type, scopes)).map((parsedFile) => {
-    return __spreadProps$9(__spreadValues$9({}, parsedFile), {
-      type: Manifest.filterSingleType(parsedFile.type, scopes, false)
-    });
-  });
-}
-
-const hookableTemplate = `
-{{#if frontmatter}}
-{{{frontmatter}}}
-{{/if}}
-
-{{{content}}}
-`.trim();
-
-var __defProp$8 = Object.defineProperty;
-var __defProps$8 = Object.defineProperties;
-var __getOwnPropDescs$8 = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols$8 = Object.getOwnPropertySymbols;
-var __hasOwnProp$8 = Object.prototype.hasOwnProperty;
-var __propIsEnum$8 = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$8 = (obj, key, value) => key in obj ? __defProp$8(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues$8 = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp$8.call(b, prop))
-      __defNormalProp$8(a, prop, b[prop]);
-  if (__getOwnPropSymbols$8)
-    for (var prop of __getOwnPropSymbols$8(b)) {
-      if (__propIsEnum$8.call(b, prop))
-        __defNormalProp$8(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps$8 = (a, b) => __defProps$8(a, __getOwnPropDescs$8(b));
-function sortMembers(shouldSortMembers, parsedFiles) {
-  return parsedFiles.map((parsedFile) => __spreadProps$8(__spreadValues$8({}, parsedFile), {
-    type: sortTypeMember(parsedFile.type, shouldSortMembers)
-  }));
-}
-function sortByNames(shouldSort, a, b) {
-  if (shouldSort) {
-    return a.name.localeCompare(b.name);
-  }
-  return 0;
-}
-function sortNamed(shouldSort, items) {
-  return items.sort((a, b) => sortByNames(shouldSort, a, b));
-}
-function sortTypeMember(type, shouldSort) {
-  switch (type.type_name) {
-    case "enum":
-      return sortEnumValues(shouldSort, type);
-    case "interface":
-      return sortInterfaceMethods(shouldSort, type);
-    case "class":
-      return sortClassMembers(shouldSort, type);
-  }
-}
-function sortEnumValues(shouldSort, enumType) {
-  return __spreadProps$8(__spreadValues$8({}, enumType), {
-    values: sortNamed(shouldSort, enumType.values)
-  });
-}
-function sortInterfaceMethods(shouldSort, interfaceType) {
-  return __spreadProps$8(__spreadValues$8({}, interfaceType), {
-    methods: sortNamed(shouldSort, interfaceType.methods)
-  });
-}
-function sortClassMembers(shouldSort, classType) {
-  return __spreadProps$8(__spreadValues$8({}, classType), {
-    fields: sortNamed(shouldSort, classType.fields),
-    classes: sortNamed(shouldSort, classType.classes),
-    enums: sortNamed(shouldSort, classType.enums),
-    interfaces: sortNamed(shouldSort, classType.interfaces),
-    methods: sortNamed(shouldSort, classType.methods),
-    properties: sortNamed(shouldSort, classType.properties)
-  });
-}
-
-function isSkip(value) {
-  return Object.prototype.hasOwnProperty.call(value, "_tag") && value._tag === "Skip";
-}
-
-function parsedFilesToReferenceGuide(config, parsedFiles) {
-  return parsedFiles.reduce((acc, parsedFile) => {
-    acc[parsedFile.type.name] = parsedFileToDocPageReference(config, parsedFile);
-    return acc;
-  }, {});
-}
-function parsedFileToDocPageReference(config, parsedFile) {
-  const path = `${slugify(getTypeGroup(parsedFile.type, config))}/${parsedFile.type.name}.md`;
-  return {
-    source: parsedFile.source,
-    displayName: parsedFile.type.name,
-    outputDocPath: path,
-    referencePath: path
-  };
-}
-function getTypeGroup(type, config) {
-  var _a, _b;
-  const groupAnnotation = (_a = type.docComment) == null ? void 0 : _a.annotations.find((annotation) => annotation.name.toLowerCase() === "group");
-  return (_b = groupAnnotation == null ? void 0 : groupAnnotation.body) != null ? _b : config.defaultGroupName;
-}
-function slugify(text) {
-  return text.toLowerCase().replace(/[^a-z0-9\s-]/g, "").trim().replace(/\s+/g, "-").replace(/-+/g, "-");
-}
-
-var __defProp$7 = Object.defineProperty;
-var __defProps$7 = Object.defineProperties;
-var __getOwnPropDescs$7 = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols$7 = Object.getOwnPropertySymbols;
-var __hasOwnProp$7 = Object.prototype.hasOwnProperty;
-var __propIsEnum$7 = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$7 = (obj, key, value) => key in obj ? __defProp$7(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues$7 = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp$7.call(b, prop))
-      __defNormalProp$7(a, prop, b[prop]);
-  if (__getOwnPropSymbols$7)
-    for (var prop of __getOwnPropSymbols$7(b)) {
-      if (__propIsEnum$7.call(b, prop))
-        __defNormalProp$7(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps$7 = (a, b) => __defProps$7(a, __getOwnPropDescs$7(b));
-var __async$5 = (__this, __arguments, generator) => {
-  return new Promise((resolve, reject) => {
-    var fulfilled = (value) => {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var rejected = (value) => {
-      try {
-        step(generator.throw(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
-    step((generator = generator.apply(__this, __arguments)).next());
-  });
-};
-class HookError {
-  constructor(error) {
-    this.error = error;
-    this._tag = "HookError";
-  }
-}
-function generateDocs(apexBundles, config) {
-  const filterOutOfScope = apply(filterScope, config.scope);
-  const convertToReferences = apply(parsedFilesToReferenceGuide, config);
-  const convertToRenderableBundle = apply(parsedFilesToRenderableBundle, config);
-  const convertToDocumentationBundleForTemplate = apply(convertToDocumentationBundle, config.referenceGuideTemplate);
-  const sortTypeMembers = apply(sortMembers, config.sortMembersAlphabetically);
-  return _function.pipe(
-    apexBundles,
-    reflectBundles,
-    TE__namespace.map(filterOutOfScope),
-    TE__namespace.map(addInheritedMembersToTypes),
-    TE__namespace.map(addInheritanceChainToTypes),
-    TE__namespace.map(sortTypeMembers),
-    TE__namespace.bindTo("parsedFiles"),
-    TE__namespace.bind("references", ({ parsedFiles }) => TE__namespace.right(convertToReferences(parsedFiles))),
-    TE__namespace.flatMap(({ parsedFiles, references }) => transformReferenceHook(config)({ references, parsedFiles })),
-    TE__namespace.map(({ parsedFiles, references }) => convertToRenderableBundle(parsedFiles, references)),
-    TE__namespace.map(convertToDocumentationBundleForTemplate),
-    TE__namespace.flatMap(transformDocumentationBundleHook(config)),
-    TE__namespace.map(postHookCompile)
-  );
-}
-function transformReferenceHook(config) {
-  function _execute(references, parsedFiles, transformReference) {
-    return __async$5(this, null, function* () {
-      return {
-        references: yield execTransformReferenceHook(Object.values(references), transformReference),
-        parsedFiles
-      };
-    });
-  }
-  return ({ references, parsedFiles }) => TE__namespace.tryCatch(
-    () => _execute(references, parsedFiles, config.transformReference),
-    (error) => new HookError(error)
-  );
-}
-function transformDocumentationBundleHook(config) {
-  return (bundle) => TE__namespace.tryCatch(
-    () => documentationBundleHook(bundle, config),
-    (error) => new HookError(error)
-  );
-}
-function passThroughHook(value) {
-  return value;
-}
-const execTransformReferenceHook = (_0, ..._1) => __async$5(void 0, [_0, ..._1], function* (references, hook = passThroughHook) {
-  const hooked = references.map((reference) => __async$5(void 0, null, function* () {
-    const hookedResult = yield hook(reference);
-    return __spreadValues$7(__spreadValues$7({}, reference), hookedResult);
-  }));
-  const awaited = yield Promise.all(hooked);
-  return awaited.reduce((acc, reference) => {
-    acc[reference.source.name] = reference;
-    return acc;
-  }, {});
-});
-const documentationBundleHook = (bundle, config) => __async$5(void 0, null, function* () {
-  return {
-    referenceGuide: yield transformReferenceGuide(bundle.referenceGuide, config.transformReferenceGuide),
-    docs: yield transformDocs(bundle.docs, config.transformDocs, config.transformDocPage)
-  };
-});
-const transformReferenceGuide = (_0, ..._1) => __async$5(void 0, [_0, ..._1], function* (referenceGuide, hook = passThroughHook) {
-  const result = yield hook(referenceGuide);
-  if (isSkip(result)) {
-    return result;
-  }
-  return __spreadValues$7(__spreadValues$7({}, referenceGuide), yield hook(referenceGuide));
-});
-const transformDocs = (_0, ..._1) => __async$5(void 0, [_0, ..._1], function* (docs, transformDocsHook = passThroughHook, transformDocPageHook = passThroughHook) {
-  const transformed = yield transformDocsHook(docs);
-  return Promise.all(transformed.map((doc) => transformDocPage(doc, transformDocPageHook)));
-});
-const transformDocPage = (_0, ..._1) => __async$5(void 0, [_0, ..._1], function* (doc, hook = passThroughHook) {
-  return __spreadValues$7(__spreadValues$7({}, doc), yield hook(doc));
-});
-function postHookCompile(bundle) {
-  return {
-    referenceGuide: isSkip(bundle.referenceGuide) ? bundle.referenceGuide : __spreadProps$7(__spreadValues$7({}, bundle.referenceGuide), {
-      content: Template.getInstance().compile({
-        source: {
-          frontmatter: toFrontmatterString(bundle.referenceGuide.frontmatter),
-          content: bundle.referenceGuide.content
-        },
-        template: hookableTemplate
-      })
-    }),
-    docs: bundle.docs.map((doc) => __spreadProps$7(__spreadValues$7({}, doc), {
-      content: Template.getInstance().compile({
-        source: {
-          frontmatter: toFrontmatterString(doc.frontmatter),
-          content: doc.content
-        },
-        template: hookableTemplate
-      })
-    }))
-  };
-}
-function toFrontmatterString(frontmatter) {
-  if (typeof frontmatter === "string") {
-    return frontmatter;
-  }
-  if (!frontmatter) {
-    return "";
-  }
-  const yamlString = yaml.dump(frontmatter);
-  return `---
-${yamlString}---
-`;
-}
-
-const referenceGuideTemplate = `
-# Apex Reference Guide
-
-{{#each this}}
-## {{@key}}
-
-{{#each this}}
-### {{link title}}
-
-{{{renderContent description}}}
-
-{{/each}}
-{{/each}}
-`.trim();
-
-var __defProp$6 = Object.defineProperty;
-var __defProps$6 = Object.defineProperties;
-var __getOwnPropDescs$6 = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols$6 = Object.getOwnPropertySymbols;
-var __hasOwnProp$6 = Object.prototype.hasOwnProperty;
-var __propIsEnum$6 = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$6 = (obj, key, value) => key in obj ? __defProp$6(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues$6 = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp$6.call(b, prop))
-      __defNormalProp$6(a, prop, b[prop]);
-  if (__getOwnPropSymbols$6)
-    for (var prop of __getOwnPropSymbols$6(b)) {
-      if (__propIsEnum$6.call(b, prop))
-        __defNormalProp$6(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps$6 = (a, b) => __defProps$6(a, __getOwnPropDescs$6(b));
-const mkdir = TE__namespace$1.taskify(fs__namespace.mkdir);
-const writeFile = TE__namespace$1.taskify(fs__namespace.writeFile);
-function writeFiles(files, outputDir, onWriteCallback) {
-  return _function.pipe(
-    files,
-    TE__namespace$1.traverseArray((file) => writeSingle(file, outputDir, onWriteCallback))
-  );
-}
-function writeSingle(file, outputDir, onWriteCallback) {
-  const ensureDirectoryExists = ({ outputDocPath }) => mkdir(path__namespace.dirname(outputDocPath), { recursive: true });
-  const writeContents = (file2) => writeFile(file2.outputDocPath, file2.content, "utf8");
-  return _function.pipe(
-    resolveTargetLocation(file, outputDir),
-    (file2) => TE__namespace$1.right(file2),
-    TE__namespace$1.tapIO(ensureDirectoryExists),
-    TE__namespace$1.flatMap(writeContents),
-    TE__namespace$1.map(() => onWriteCallback == null ? void 0 : onWriteCallback(file))
-  );
-}
-function resolveTargetLocation(file, outputDir) {
-  return __spreadProps$6(__spreadValues$6({}, file), {
-    outputDocPath: path__namespace.join(outputDir, file.outputDocPath)
-  });
-}
-
-var __defProp$5 = Object.defineProperty;
-var __defProps$5 = Object.defineProperties;
-var __getOwnPropDescs$5 = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols$5 = Object.getOwnPropertySymbols;
-var __hasOwnProp$5 = Object.prototype.hasOwnProperty;
-var __propIsEnum$5 = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$5 = (obj, key, value) => key in obj ? __defProp$5(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues$5 = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp$5.call(b, prop))
-      __defNormalProp$5(a, prop, b[prop]);
-  if (__getOwnPropSymbols$5)
-    for (var prop of __getOwnPropSymbols$5(b)) {
-      if (__propIsEnum$5.call(b, prop))
-        __defNormalProp$5(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps$5 = (a, b) => __defProps$5(a, __getOwnPropDescs$5(b));
-class FileWritingError {
-  constructor(message, error) {
-    this.message = message;
-    this.error = error;
-    this._tag = "FileWritingError";
-  }
-}
-function generate(bundles, config) {
-  return _function.pipe(
-    generateDocumentationBundle(bundles, config),
-    TE__namespace.flatMap((files) => writeFilesToSystem(files, config.targetDir))
-  );
-}
-function generateDocumentationBundle(bundles, config) {
-  return generateDocs(bundles, __spreadProps$5(__spreadValues$5({}, config), {
-    referenceGuideTemplate
-  }));
-}
-function writeFilesToSystem(files, outputDir) {
-  return _function.pipe(
-    [files.referenceGuide, ...files.docs].filter((file) => !isSkip(file)),
-    (files2) => writeFiles(files2, outputDir),
-    TE__namespace.mapLeft((error) => {
-      return new FileWritingError("An error occurred while writing files to the system.", error);
-    })
-  );
-}
-
-function createManifest(typeParser, reflect) {
-  return new Manifest(typeParser.parse(reflect));
-}
-
-class Logger {
-  /**
-   * Logs a message with optional arguments.
-   * @param message The message to log.
-   * @param args Optional arguments.
-   */
-  static log(message, ...args) {
-    this.logSingle(message);
-    args.forEach((arg) => {
-      this.logSingle(arg);
-    });
-  }
-  /**
-   * Logs an error message with optional arguments.
-   * @param message The error message to log.
-   * @param args Optional arguments.
-   */
-  static error(message, ...args) {
-    this.logSingle(message, "red");
-    args.forEach(() => {
-      this.logSingle(message, "red");
-    });
-  }
-  static logSingle(text, color = "green") {
-    if (this.currentFrame > 9) {
-      this.currentFrame = 0;
-    }
-    const logMessage = `${this.getChalkFn(color)((/* @__PURE__ */ new Date()).toLocaleString() + ": ")}${text}
-`;
-    process.stdout.write(logMessage);
-  }
-  static getChalkFn(color) {
-    return color === "green" ? chalk.green : chalk.red;
-  }
-}
-Logger.currentFrame = 0;
-
-var __defProp$4 = Object.defineProperty;
-var __defProps$4 = Object.defineProperties;
-var __getOwnPropDescs$4 = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols$4 = Object.getOwnPropertySymbols;
-var __hasOwnProp$4 = Object.prototype.hasOwnProperty;
-var __propIsEnum$4 = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$4 = (obj, key, value) => key in obj ? __defProp$4(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues$4 = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp$4.call(b, prop))
-      __defNormalProp$4(a, prop, b[prop]);
-  if (__getOwnPropSymbols$4)
-    for (var prop of __getOwnPropSymbols$4(b)) {
-      if (__propIsEnum$4.call(b, prop))
-        __defNormalProp$4(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps$4 = (a, b) => __defProps$4(a, __getOwnPropDescs$4(b));
-class RawBodyParser {
-  constructor(typeBundles) {
-    this.typeBundles = typeBundles;
-  }
-  parse(reflect) {
-    const types = this.typeBundles.map((currentBundle) => {
-      Logger.log(`Parsing file: ${currentBundle.filePath}`);
-      return reflect(currentBundle);
-    }).filter((reflectionResult) => {
-      return reflectionResult.typeMirror;
-    }).map((reflectionResult) => reflectionResult.typeMirror);
-    return this.addFieldsFromParent(types);
-  }
-  addFieldsFromParent(types) {
-    const typesWithFields = [];
-    for (const currentType of types) {
-      if (currentType.type_name !== "class" && currentType.type_name !== "interface") {
-        typesWithFields.push(currentType);
-        continue;
-      }
-      if (currentType.type_name === "class") {
-        let typeAsClass = currentType;
-        if (!typeAsClass.extended_class) {
-          typesWithFields.push(currentType);
-          continue;
-        }
-        typeAsClass = this.addMembersFromParent(typeAsClass, types);
-        typesWithFields.push(typeAsClass);
-        continue;
-      }
-      let typeAsInterface = currentType;
-      if (!typeAsInterface.extended_interfaces.length) {
-        typesWithFields.push(currentType);
-        continue;
-      }
-      typeAsInterface = this.addMethodsFromParent(typeAsInterface, types);
-      typesWithFields.push(typeAsInterface);
-    }
-    return typesWithFields;
-  }
-  addMembersFromParent(currentClass, allTypes) {
-    if (!currentClass.extended_class) {
-      return currentClass;
-    }
-    const parent = allTypes.find((currentType) => currentType.name === currentClass.extended_class);
-    if (!parent || parent.type_name !== "class") {
-      return currentClass;
-    }
-    let parentAsClass = parent;
-    if (parentAsClass.extended_class) {
-      parentAsClass = this.addMembersFromParent(parentAsClass, allTypes);
-    }
-    currentClass.fields = [...currentClass.fields, ...this.getInheritedFields(parentAsClass, currentClass)];
-    currentClass.properties = [...currentClass.properties, ...this.getInheritedProperties(parentAsClass, currentClass)];
-    currentClass.methods = [...currentClass.methods, ...this.getInheritedMethods(parentAsClass, currentClass)];
-    return currentClass;
-  }
-  addMethodsFromParent(currentInterface, allTypes) {
-    if (!currentInterface.extended_interfaces.length) {
-      return currentInterface;
-    }
-    const parents = [];
-    for (const currentInterfaceName of currentInterface.extended_interfaces) {
-      const parent = allTypes.find((currentType) => currentType.name === currentInterfaceName);
-      if (parent) {
-        parents.push(parent);
-      }
-    }
-    for (const parent of parents) {
-      let parentAsInterface = parent;
-      if (parentAsInterface.extended_interfaces.length) {
-        parentAsInterface = this.addMethodsFromParent(parentAsInterface, allTypes);
-      }
-      currentInterface.methods = [
-        ...currentInterface.methods,
-        ...this.getInheritedMethods(parentAsInterface, currentInterface)
-      ];
-    }
-    return currentInterface;
-  }
-  getInheritedFields(parentAsClass, currentClass) {
-    return parentAsClass.fields.filter((currentField) => currentField.access_modifier.toLowerCase() !== "private").filter((currentField) => !this.memberExists(currentClass.fields, currentField.name)).map((currentField) => __spreadProps$4(__spreadValues$4({}, currentField), {
-      inherited: true
-    }));
-  }
-  getInheritedProperties(parentAsClass, currentClass) {
-    return parentAsClass.properties.filter((currentProperty) => currentProperty.access_modifier.toLowerCase() !== "private").filter((currentProperty) => !this.memberExists(currentClass.properties, currentProperty.name)).map((currentProperty) => __spreadProps$4(__spreadValues$4({}, currentProperty), {
-      inherited: true
-    }));
-  }
-  getInheritedMethods(parentAsClass, currentClass) {
-    return parentAsClass.methods.filter((currentMethod) => currentMethod.access_modifier.toLowerCase() !== "private").filter((currentMethod) => !this.memberExists(currentClass.methods, currentMethod.name)).map((currentMethod) => __spreadProps$4(__spreadValues$4({}, currentMethod), {
-      inherited: true
-    }));
-  }
-  memberExists(members, fieldName) {
-    const fieldNames = members.map((currentMember) => currentMember.name);
-    return fieldNames.includes(fieldName);
-  }
-}
-
-class TypesRepository {
-  constructor() {
-    this.allTypes = [];
-  }
-  static getInstance() {
-    if (!TypesRepository.instance) {
-      TypesRepository.instance = new TypesRepository();
-    }
-    return TypesRepository.instance;
-  }
-  populateAll(types) {
-    this.allTypes = types;
-  }
-  getFromAllByName(typeName) {
-    if (typeName.includes(".")) {
-      const [parentTypeName, childTypeName] = typeName.split(".");
-      const parentReference = this.allTypes.find(
-        (currentType) => currentType.name.toLowerCase() === parentTypeName.toLowerCase()
-      );
-      if (!parentReference || parentReference.type_name !== "class") {
-        return void 0;
-      }
-      const parentReferenceAsClass = parentReference;
-      const childTypes = [
-        ...parentReferenceAsClass.classes,
-        ...parentReferenceAsClass.interfaces,
-        ...parentReferenceAsClass.enums
-      ];
-      const foundType2 = childTypes.find((currentType) => currentType.name.toLowerCase() === childTypeName);
-      if (!foundType2) {
-        return void 0;
-      }
-      return { type: foundType2, isChild: true, parentType: parentReference };
-    }
-    const foundType = this.allTypes.find(
-      (currentType) => currentType.name.toLowerCase() === typeName.toLowerCase()
-    );
-    if (!foundType) {
-      return void 0;
-    }
-    return { type: foundType, isChild: false };
-  }
-}
-
-class Transpiler {
-  static generate(types, processor) {
-    var _a;
-    const sortedTypes = types.sort((apexTypeA, apexTypeB) => {
-      if (apexTypeA.name < apexTypeB.name) return -1;
-      if (apexTypeA.name > apexTypeB.name) return 1;
-      return 0;
-    });
-    sortedTypes.forEach((currentType) => {
-      processor.onProcess(currentType);
-    });
-    (_a = processor.onAfterProcess) == null ? void 0 : _a.call(processor, sortedTypes);
-  }
-}
-
-class ErrorLogger {
-  static logErrors(types) {
-    types.forEach((currentType) => {
-      this.logErrorsForSingleType(currentType);
-    });
-  }
-  static logErrorsForSingleType(currentType) {
-    this.logTypeErrors(currentType);
-    if (currentType.type_name === "class") {
-      this.logErrorsForClass(currentType);
-    } else if (currentType.type_name === "interface") {
-      this.logErrorsForInterface(currentType);
-    }
-  }
-  static logTypeErrors(currentType, parentType) {
-    var _a;
-    if ((_a = currentType.docComment) == null ? void 0 : _a.error) {
-      const typeName = parentType ? `${parentType.name}.${currentType.name}` : currentType.name;
-      Logger.error(`${typeName} - Doc comment parsing error. Level: Type`);
-      Logger.error(`Comment:
- ${currentType.docComment.rawDeclaration}`);
-      Logger.error(currentType.docComment.error);
-      Logger.error("=================================");
-    }
-  }
-  static logErrorsForClass(classMirror, parentType) {
-    const typeName = parentType ? `${parentType.name}.${classMirror.name}` : classMirror.name;
-    classMirror.constructors.forEach((currentConstructor) => {
-      var _a;
-      if ((_a = currentConstructor.docComment) == null ? void 0 : _a.error) {
-        Logger.error(`${typeName} - Doc comment parsing error. Level: Constructor`);
-        Logger.error(`Comment:
- ${currentConstructor.docComment.rawDeclaration}`);
-        Logger.error(currentConstructor.docComment.error);
-        Logger.error("=================================");
-      }
-    });
-    classMirror.fields.forEach((currentField) => {
-      var _a;
-      if ((_a = currentField.docComment) == null ? void 0 : _a.error) {
-        Logger.error(`${typeName} - Doc comment parsing error. Level: Field`);
-        Logger.error(`Comment:
- ${currentField.docComment.rawDeclaration}`);
-        Logger.error(currentField.docComment.error);
-        Logger.error("=================================");
-      }
-    });
-    classMirror.properties.forEach((currentProperty) => {
-      var _a;
-      if ((_a = currentProperty.docComment) == null ? void 0 : _a.error) {
-        Logger.error(`${typeName} - Doc comment parsing error. Level: Property`);
-        Logger.error(`Comment:
- ${currentProperty.docComment.rawDeclaration}`);
-        Logger.error(currentProperty.docComment.error);
-        Logger.error("=================================");
-      }
-    });
-    classMirror.methods.forEach((currentMethod) => {
-      var _a;
-      if ((_a = currentMethod.docComment) == null ? void 0 : _a.error) {
-        Logger.error(`${typeName} - Doc comment parsing error. Level: Method`);
-        Logger.error(`Comment:
- ${currentMethod.docComment.rawDeclaration}`);
-        Logger.error(currentMethod.docComment.error);
-        Logger.error("=================================");
-      }
-    });
-    classMirror.enums.forEach((currentEnum) => {
-      this.logErrorsForSingleType(currentEnum);
-    });
-    classMirror.interfaces.forEach((currentInterface) => {
-      this.logErrorsForSingleType(currentInterface);
-    });
-    classMirror.classes.forEach((currentClass) => {
-      this.logErrorsForSingleType(currentClass);
-    });
-  }
-  static logErrorsForInterface(interfaceMirror) {
-    interfaceMirror.methods.forEach((currentMethod) => {
-      var _a;
-      if ((_a = currentMethod.docComment) == null ? void 0 : _a.error) {
-        Logger.error(`${interfaceMirror.name} - Doc comment parsing error. Level: Method`);
-        Logger.error(`Comment: ${currentMethod.docComment.rawDeclaration}`);
-        Logger.error(currentMethod.docComment.error);
-        Logger.error("=================================");
-      }
-    });
-  }
-}
-
-class FileContainer {
-  constructor() {
-    this._files = [];
-  }
-  files() {
-    return this._files;
-  }
-  pushFile(file) {
-    this._files.push(file);
-  }
-}
-
-const OPEN_API_VERSION = "3.1.0";
-const SERVER_URL = "/services/apexrest/";
-class OpenApi {
-  constructor(title, version, namespace) {
-    this.namespace = namespace;
-    this.openapi = OPEN_API_VERSION;
-    this.info = {
-      title,
-      version
-    };
-    this.servers = [
-      {
-        url: this.getServerUrl()
-      }
-    ];
-    this.paths = {};
-    this.tags = [];
-  }
-  getServerUrl() {
-    if (!this.namespace) {
-      return SERVER_URL;
-    }
-    return `${SERVER_URL}${this.namespace}/`;
-  }
-}
-
-class OpenApiSettings {
-  constructor(config) {
-    this.config = config;
-  }
-  static build(config) {
-    OpenApiSettings.instance = new OpenApiSettings(config);
-  }
-  static getInstance() {
-    if (!OpenApiSettings.instance) {
-      throw new Error("Settings has not been initialized");
-    }
-    return OpenApiSettings.instance;
-  }
-  getOpenApiTitle() {
-    return this.config.openApiTitle;
-  }
-  getNamespace() {
-    return this.config.namespace;
-  }
-  openApiFileName() {
-    return this.config.openApiFileName;
-  }
-  getVersion() {
-    return this.config.version;
-  }
-}
-
-class ClassMirrorWrapper {
-  constructor(classMirror) {
-    this.classMirror = classMirror;
-    this.hasAnnotation = (method, annotationName) => method.annotations.some((annotation) => annotation.name.toLowerCase() === annotationName);
-  }
-  getMethodsByAnnotation(annotation) {
-    return this.classMirror.methods.filter((method) => this.hasAnnotation(method, annotation));
-  }
-}
-
-var __defProp$3 = Object.defineProperty;
-var __defProps$3 = Object.defineProperties;
-var __getOwnPropDescs$3 = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols$3 = Object.getOwnPropertySymbols;
-var __hasOwnProp$3 = Object.prototype.hasOwnProperty;
-var __propIsEnum$3 = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues$3 = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp$3.call(b, prop))
-      __defNormalProp$3(a, prop, b[prop]);
-  if (__getOwnPropSymbols$3)
-    for (var prop of __getOwnPropSymbols$3(b)) {
-      if (__propIsEnum$3.call(b, prop))
-        __defNormalProp$3(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps$3 = (a, b) => __defProps$3(a, __getOwnPropDescs$3(b));
-class ReferenceBuilder {
-  constructor() {
-    this.isReferenceString = (targetObject) => {
-      return typeof targetObject === "string" || targetObject instanceof String;
-    };
-  }
-  build(referencedTypeName) {
-    const originalTypeName = referencedTypeName;
-    const regexForSchemaOverrides = /\[(.*?)]/g;
-    const schemaOverrides = referencedTypeName.match(regexForSchemaOverrides);
-    let referenceOverrides = [];
-    if (schemaOverrides && schemaOverrides.length > 0) {
-      referenceOverrides = ReferenceOverrides.build(schemaOverrides[0]);
-      referencedTypeName = referencedTypeName.replace(regexForSchemaOverrides, "");
-    }
-    const [parsedReferencedType, isCollection] = this.handlePossibleCollectionReference(referencedTypeName);
-    const referencedTypeBundle = TypesRepository.getInstance().getFromAllByName(parsedReferencedType);
-    if (!referencedTypeBundle) {
-      throw new Error(`The referenced type ${referencedTypeName} was not found.`);
-    }
-    if (referencedTypeBundle.type.type_name !== "class") {
-      throw new Error(
-        `Expected the referenced type to be a class, but found a ${referencedTypeBundle.type.type_name}.`
-      );
-    }
-    const typeBundleWithIsCollection = __spreadProps$3(__spreadValues$3({}, referencedTypeBundle), {
-      originalTypeName,
-      isCollection,
-      referenceOverrides
-    });
-    return this.buildReferenceFromType(typeBundleWithIsCollection);
-  }
-  /**
-   * Returns a tuple where the first value is the name of the reference without any collection related values
-   * and the second is a boolean representing if we are dealing with a collection or not.
-   * @param referencedTypeName The received raw type name.
-   * @private
-   */
-  handlePossibleCollectionReference(referencedTypeName) {
-    referencedTypeName = referencedTypeName.toLowerCase();
-    if (referencedTypeName.startsWith("list<") && referencedTypeName.endsWith(">")) {
-      referencedTypeName = referencedTypeName.replace("list<", "");
-      referencedTypeName = referencedTypeName.replace(">", "");
-      return [referencedTypeName, true];
-    }
-    if (referencedTypeName.startsWith("set<") && referencedTypeName.endsWith(">")) {
-      referencedTypeName = referencedTypeName.replace("set<", "");
-      referencedTypeName = referencedTypeName.replace(">", "");
-      return [referencedTypeName, true];
-    }
-    return [referencedTypeName, false];
-  }
-  buildReferenceFromType(typeBundle) {
-    const propertiesAndFields = [
-      ...typeBundle.type.properties,
-      ...typeBundle.type.fields
-    ].filter((current) => !current.memberModifiers.includes("static")).filter((current) => !current.memberModifiers.includes("transient"));
-    const properties = {};
-    let referencedComponents = [];
-    propertiesAndFields.forEach((current) => {
-      var _a, _b;
-      const referenceOverride = typeBundle.referenceOverrides.find((currentOverride) => {
-        return currentOverride.propertyName.toLowerCase() === current.name.toLowerCase();
-      });
-      if (referenceOverride) {
-        const reference = this.build(referenceOverride.referenceName);
-        properties[current.name] = reference.entrypointReferenceObject;
-        reference.referenceComponents.forEach((current2) => referencedComponents.push(current2));
-      } else {
-        const manuallyDefinedHttpSchema = (_a = current.docComment) == null ? void 0 : _a.annotations.find(
-          (annotation) => annotation.name.toLowerCase() === "http-schema"
-        );
-        if (manuallyDefinedHttpSchema) {
-          this.handleOverriddenSchema(manuallyDefinedHttpSchema, properties, current, referencedComponents);
-        } else {
-          const pair = this.getReferenceType(current.typeReference);
-          properties[current.name] = pair.schema;
-          referencedComponents.push(...pair.referenceComponents);
-        }
-      }
-      properties[current.name].description = (_b = current.docComment) == null ? void 0 : _b.description;
-    });
-    const mainReferenceComponents = this.buildMainReferenceComponent(typeBundle, properties);
-    referencedComponents = [...mainReferenceComponents, ...referencedComponents];
-    return {
-      entrypointReferenceObject: {
-        $ref: `#/components/schemas/${this.getReferenceName(typeBundle)}`
-      },
-      referenceComponents: referencedComponents
-    };
-  }
-  handleOverriddenSchema(manuallyDefinedHttpSchema, properties, current, referencedComponents) {
-    const inYaml = manuallyDefinedHttpSchema == null ? void 0 : manuallyDefinedHttpSchema.bodyLines.reduce((prev, current2) => prev + "\n" + current2);
-    const asJson = yaml__namespace.load(inYaml);
-    const isReferenceString = this.isReferenceString(asJson);
-    if (isReferenceString) {
-      const reference = this.build(asJson);
-      properties[current.name] = reference.entrypointReferenceObject;
-      reference.referenceComponents.forEach((current2) => referencedComponents.push(current2));
-    } else {
-      properties[current.name] = asJson;
-    }
-  }
-  getReferenceName(typeBundle) {
-    var _a;
-    let referenceName = typeBundle.type.name;
-    if (typeBundle.isChild) {
-      referenceName = `${(_a = typeBundle.parentType) == null ? void 0 : _a.name}.${typeBundle.type.name}`;
-    }
-    if (typeBundle.isCollection) {
-      referenceName = `${referenceName}_array`;
-    }
-    if (typeBundle.referenceOverrides.length) {
-      referenceName = `${referenceName}_${typeBundle.originalTypeName}`;
-    }
-    return referenceName;
-  }
-  buildMainReferenceComponent(typeBundle, properties) {
-    const mainReferenceName = this.getReferenceName(__spreadProps$3(__spreadValues$3({}, typeBundle), { isCollection: false }));
-    const mainReference = {
-      referencedClass: mainReferenceName,
-      schema: {
-        type: "object",
-        properties
-      }
-    };
-    const referencedComponents = [mainReference];
-    if (!typeBundle.isCollection) {
-      return referencedComponents;
-    }
-    return [
-      {
-        referencedClass: this.getReferenceName(typeBundle),
-        schema: {
-          type: "array",
-          items: {
-            $ref: `#/components/schemas/${mainReferenceName}`
-          }
-        }
-      },
-      ...referencedComponents
-    ];
-  }
-  getReferenceType(typeInMirror) {
-    const typeName = typeInMirror.type.toLowerCase();
-    switch (typeName) {
-      case "boolean":
-        return { schema: { type: "boolean" }, referenceComponents: [] };
-      case "date":
-        return { schema: { type: "string", format: "date" }, referenceComponents: [] };
-      case "datetime":
-        return { schema: { type: "string", format: "date-time" }, referenceComponents: [] };
-      case "decimal":
-        return { schema: { type: "number" }, referenceComponents: [] };
-      case "double":
-        return { schema: { type: "number" }, referenceComponents: [] };
-      case "id":
-        return { schema: { type: "string" }, referenceComponents: [] };
-      case "integer":
-        return { schema: { type: "integer" }, referenceComponents: [] };
-      case "long":
-        return { schema: { type: "integer", format: "int64" }, referenceComponents: [] };
-      case "string":
-        return { schema: { type: "string" }, referenceComponents: [] };
-      case "time":
-        return { schema: { type: "string", format: "time" }, referenceComponents: [] };
-      case "list":
-        return this.buildCollectionPair(typeInMirror);
-      case "set":
-        return this.buildCollectionPair(typeInMirror);
-      case "map":
-        return { schema: { type: "object" }, referenceComponents: [] };
-      case "object":
-        return { schema: { type: "object" }, referenceComponents: [] };
-      default: {
-        const referencedType = TypesRepository.getInstance().getFromAllByName(typeName);
-        if (!referencedType) {
-          return { schema: { type: "object" }, referenceComponents: [] };
-        }
-        const reference = this.buildReferenceFromType(__spreadProps$3(__spreadValues$3({}, referencedType), {
-          isCollection: false,
-          referenceOverrides: [],
-          originalTypeName: typeName
-        }));
-        return {
-          schema: reference.entrypointReferenceObject,
-          referenceComponents: [...reference.referenceComponents]
-        };
-      }
-    }
-  }
-  buildCollectionPair(typeInMirror) {
-    const innerReference = this.getReferenceType(typeInMirror.ofType);
-    return {
-      schema: { type: "array", items: innerReference.schema },
-      referenceComponents: [...innerReference.referenceComponents]
-    };
-  }
-}
-class ReferenceOverrides {
-  static build(referenceAsString) {
-    const cleanedUpReference = referenceAsString.replace(/[[\]]/g, "");
-    const referenceStrings = cleanedUpReference.split(",").map((item) => item.replace(/\s/g, ""));
-    return referenceStrings.map((item) => {
-      const [propertyName, referenceName] = item.split(":");
-      return { propertyName, referenceName };
-    });
-  }
-}
-
-class Builder {
-  constructor() {
-    this.isReferenceString = (targetObject) => {
-      return typeof targetObject === "string" || targetObject instanceof String;
-    };
-  }
-  build(schemaAware) {
-    let reference;
-    if (this.isReferenceString(schemaAware.schema)) {
-      reference = new ReferenceBuilder().build(schemaAware.schema);
-    }
-    return {
-      reference,
-      body: this.buildBody(schemaAware, reference)
-    };
-  }
-  getOpenApiSchemaFromApexDocSchema(schemaAware, reference) {
-    if (this.isReferenceString(schemaAware.schema)) {
-      return reference.entrypointReferenceObject;
-    }
-    return schemaAware.schema;
-  }
-}
-
-var __defProp$2 = Object.defineProperty;
-var __defProps$2 = Object.defineProperties;
-var __getOwnPropDescs$2 = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols$2 = Object.getOwnPropertySymbols;
-var __hasOwnProp$2 = Object.prototype.hasOwnProperty;
-var __propIsEnum$2 = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues$2 = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp$2.call(b, prop))
-      __defNormalProp$2(a, prop, b[prop]);
-  if (__getOwnPropSymbols$2)
-    for (var prop of __getOwnPropSymbols$2(b)) {
-      if (__propIsEnum$2.call(b, prop))
-        __defNormalProp$2(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps$2 = (a, b) => __defProps$2(a, __getOwnPropDescs$2(b));
-class ParameterObjectBuilder extends Builder {
-  buildBody(apexDocObject, reference) {
-    return __spreadProps$2(__spreadValues$2({}, apexDocObject), {
-      schema: this.getOpenApiSchemaFromApexDocSchema(apexDocObject, reference)
-    });
-  }
-}
-
-class ResponsesBuilder extends Builder {
-  buildBody(apexDocResponseDefinition, reference) {
-    let description = `Status code ${apexDocResponseDefinition.statusCode}`;
-    if (apexDocResponseDefinition.description) {
-      description = apexDocResponseDefinition.description;
-    }
-    return {
-      description,
-      content: {
-        "application/json": {
-          schema: this.getOpenApiSchemaFromApexDocSchema(apexDocResponseDefinition, reference)
-        }
-      }
-    };
-  }
-}
-
-class RequestBodyBuilder extends Builder {
-  buildBody(apexRequestBody, reference) {
-    return {
-      description: apexRequestBody.description,
-      content: {
-        "application/json": { schema: this.getOpenApiSchemaFromApexDocSchema(apexRequestBody, reference) }
-      },
-      required: apexRequestBody.required
-    };
-  }
-}
-
-class MethodMirrorWrapper {
-  constructor(methodMirror) {
-    this.methodMirror = methodMirror;
-    this.hasDocCommentAnnotation = (annotationName) => {
-      var _a;
-      return (_a = this.methodMirror.docComment) == null ? void 0 : _a.annotations.some((annotation) => annotation.name.toLowerCase() === annotationName);
-    };
-    this.getDocCommentAnnotation = (annotationName) => {
-      var _a;
-      return (_a = this.methodMirror.docComment) == null ? void 0 : _a.annotations.find((annotation) => annotation.name.toLowerCase() === annotationName);
-    };
-  }
-}
+var logger$1 = require('../logger-Ce4QqPFR.js');
+var cosmiconfig = require('cosmiconfig');
+var yargs = require('yargs');
+var cosmiconfigTypescriptLoader = require('cosmiconfig-typescript-loader');
+var E = require('fp-ts/Either');
+require('fp-ts/function');
+require('fp-ts/TaskEither');
+require('js-yaml');
+require('path');
+require('fp-ts/Task');
+require('fp-ts/lib/Array');
+require('@cparra/apex-reflection');
+require('fp-ts/Option');
+require('fast-xml-parser');
+require('handlebars');
+require('fp-ts/boolean');
+require('fs');
+require('fp-ts/lib/TaskEither');
+require('chalk');
 
-class MethodParser {
-  constructor(openApiModel) {
-    this.openApiModel = openApiModel;
-  }
-  parseMethod(classMirror, httpUrlEndpoint, httpMethodKey, tag) {
-    var _a, _b;
-    const classMirrorWrapper = new ClassMirrorWrapper(classMirror);
-    const httpMethods = classMirrorWrapper.getMethodsByAnnotation(`http${httpMethodKey}`);
-    if (!httpMethods.length) {
-      return;
-    }
-    const httpMethod = httpMethods[0];
-    this.openApiModel.paths[httpUrlEndpoint][httpMethodKey] = {};
-    this.openApiModel.paths[httpUrlEndpoint][httpMethodKey].tags = [tag];
-    if ((_a = httpMethod.docComment) == null ? void 0 : _a.description) {
-      this.openApiModel.paths[httpUrlEndpoint][httpMethodKey].description = httpMethod.docComment.description;
-    }
-    const methodMirrorWrapper = new MethodMirrorWrapper(httpMethod);
-    if (methodMirrorWrapper.hasDocCommentAnnotation("summary")) {
-      this.openApiModel.paths[httpUrlEndpoint][httpMethodKey].summary = (_b = methodMirrorWrapper.getDocCommentAnnotation("summary")) == null ? void 0 : _b.body;
-    }
-    this.parseHttpAnnotation(
-      httpMethod,
-      httpUrlEndpoint,
-      httpMethodKey,
-      "http-request-body",
-      this.addRequestBodyToOpenApi.bind(this),
-      this.fallbackHttpRequestBodyParser(httpUrlEndpoint, httpMethodKey)
-    );
-    this.parseHttpAnnotation(
-      httpMethod,
-      httpUrlEndpoint,
-      httpMethodKey,
-      "http-parameter",
-      this.addParametersToOpenApi.bind(this)
-    );
-    this.parseHttpAnnotation(
-      httpMethod,
-      httpUrlEndpoint,
-      httpMethodKey,
-      "http-response",
-      this.addHttpResponsesToOpenApi.bind(this),
-      this.getFallbackHttpResponseParser(httpUrlEndpoint, httpMethodKey)
-    );
-  }
-  parseHttpAnnotation(httpMethod, urlValue, httpMethodKey, annotationName, addToOpenApi, fallbackParser) {
-    var _a;
-    const annotations = (_a = httpMethod.docComment) == null ? void 0 : _a.annotations.filter((annotation) => annotation.name === annotationName);
-    if (!(annotations == null ? void 0 : annotations.length)) {
-      if (fallbackParser) {
-        fallbackParser(httpMethod);
-      }
-      return;
-    }
-    for (const annotation of annotations) {
-      const inYaml = annotation == null ? void 0 : annotation.bodyLines.reduce((prev, current) => prev + "\n" + current);
-      if (!inYaml) {
-        return;
-      }
-      this.addToOpenApiStrategy(inYaml, urlValue, httpMethodKey, addToOpenApi);
-    }
-  }
-  addToOpenApiStrategy(inYaml, urlValue, httpMethodKey, addToOpenApi) {
-    const inJson = yaml__namespace.load(inYaml);
-    const requestBodyResponse = new RequestBodyBuilder().build(inJson);
-    addToOpenApi(inJson, urlValue, httpMethodKey);
-    this.addReference(requestBodyResponse);
-  }
-  addRequestBodyToOpenApi(input, urlValue, httpMethodKey) {
-    const requestBodyResponse = new RequestBodyBuilder().build(input);
-    this.openApiModel.paths[urlValue][httpMethodKey].requestBody = requestBodyResponse.body;
-  }
-  addParametersToOpenApi(input, urlValue, httpMethodKey) {
-    const parameterObjectResponse = new ParameterObjectBuilder().build(input);
-    if (this.openApiModel.paths[urlValue][httpMethodKey].parameters === void 0) {
-      this.openApiModel.paths[urlValue][httpMethodKey].parameters = [];
-    }
-    this.openApiModel.paths[urlValue][httpMethodKey].parameters.push(parameterObjectResponse.body);
-  }
-  addHttpResponsesToOpenApi(input, urlValue, httpMethodKey) {
-    const responseObjectResponse = new ResponsesBuilder().build(input);
-    if (this.openApiModel.paths[urlValue][httpMethodKey].responses === void 0) {
-      this.openApiModel.paths[urlValue][httpMethodKey].responses = {};
-    }
-    this.openApiModel.paths[urlValue][httpMethodKey].responses[input.statusCode] = responseObjectResponse.body;
-  }
-  fallbackHttpRequestBodyParser(httpUrlEndpoint, httpMethodKey) {
-    return (methodMirror) => {
-      const parameters = methodMirror.parameters;
-      if (!parameters.length) {
-        return;
-      }
-      const propertiesObject = {};
-      parameters.forEach((currentParameter) => {
-        const propertyKey = currentParameter.name;
-        const propertyReference = new ReferenceBuilder().getReferenceType(currentParameter.typeReference);
-        propertiesObject[propertyKey] = propertyReference.schema;
-        this.addReference({
-          reference: {
-            entrypointReferenceObject: propertyReference.schema,
-            referenceComponents: propertyReference.referenceComponents
-          }
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
         });
-      });
-      this.openApiModel.paths[httpUrlEndpoint][httpMethodKey].requestBody = {
-        content: {
-          "application/json": {
-            schema: {
-              type: "object",
-              properties: propertiesObject
-            }
-          }
-        }
-      };
-    };
-  }
-  getFallbackHttpResponseParser(httpUrlEndpoint, httpMethodKey) {
-    return (methodMirror) => {
-      var _a, _b;
-      const returnType = methodMirror.typeReference;
-      if (returnType.type.toLowerCase() === "void") {
-        return;
-      }
-      const reference = new ReferenceBuilder().getReferenceType(returnType);
-      this.addReference({
-        reference: {
-          entrypointReferenceObject: reference.schema,
-          referenceComponents: reference.referenceComponents
-        }
-      });
-      if (this.openApiModel.paths[httpUrlEndpoint][httpMethodKey].responses === void 0) {
-        this.openApiModel.paths[httpUrlEndpoint][httpMethodKey].responses = {};
-      }
-      this.openApiModel.paths[httpUrlEndpoint][httpMethodKey].responses["200"] = {
-        description: (_b = (_a = methodMirror.docComment) == null ? void 0 : _a.description) != null ? _b : "Status code 200",
-        content: {
-          "application/json": { schema: reference.schema }
-        }
-      };
-    };
-  }
-  addReference(referenceHolder) {
-    if (referenceHolder.reference) {
-      if (this.openApiModel.components === void 0) {
-        this.openApiModel.components = {
-          schemas: {}
-        };
-      }
-      if (!referenceHolder.reference.referenceComponents.length) {
-        return;
-      }
-      referenceHolder.reference.referenceComponents.forEach((current) => {
-        this.openApiModel.components.schemas[current.referencedClass] = current.schema;
-      });
-    }
-  }
-}
-
-const camel2title = (camelCase) => camelCase.replace(/\//g, " ").replace(/([A-Z])/g, (match) => ` ${match}`).replace(/\b\w/g, (match) => match.toUpperCase()).replace(/^./, (match) => match.toUpperCase()).trim();
-
-var __defProp$1 = Object.defineProperty;
-var __defProps$1 = Object.defineProperties;
-var __getOwnPropDescs$1 = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols$1 = Object.getOwnPropertySymbols;
-var __hasOwnProp$1 = Object.prototype.hasOwnProperty;
-var __propIsEnum$1 = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues$1 = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp$1.call(b, prop))
-      __defNormalProp$1(a, prop, b[prop]);
-  if (__getOwnPropSymbols$1)
-    for (var prop of __getOwnPropSymbols$1(b)) {
-      if (__propIsEnum$1.call(b, prop))
-        __defNormalProp$1(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps$1 = (a, b) => __defProps$1(a, __getOwnPropDescs$1(b));
-function createOpenApiFile(fileName, openApiModel) {
-  const content = JSON.stringify(__spreadProps$1(__spreadValues$1({}, openApiModel), { namespace: void 0 }), null, 2);
-  return {
-    outputDocPath: `${fileName}.json`,
-    content,
-    frontmatter: null,
-    group: null
-  };
-}
-
-class OpenApiDocsProcessor {
-  constructor() {
-    this.onAfterProcess = () => {
-      const page = createOpenApiFile(OpenApiSettings.getInstance().openApiFileName(), this.openApiModel);
-      this._fileContainer.pushFile(page);
-    };
-    this._fileContainer = new FileContainer();
-    const title = OpenApiSettings.getInstance().getOpenApiTitle();
-    if (!title) {
-      throw Error("No OpenApi title was provided.");
-    }
-    this.openApiModel = new OpenApi(
-      title,
-      OpenApiSettings.getInstance().getVersion(),
-      OpenApiSettings.getInstance().getNamespace()
-    );
-  }
-  fileBuilder() {
-    return this._fileContainer;
-  }
-  onProcess(type) {
-    var _a, _b;
-    Logger.logSingle(`Processing ${type.name}`, "green");
-    const endpointPath = this.getEndpointPath(type);
-    if (!endpointPath) {
-      return;
-    }
-    this.openApiModel.paths[endpointPath] = {};
-    if ((_a = type.docComment) == null ? void 0 : _a.description) {
-      this.openApiModel.paths[endpointPath].description = type.docComment.description;
-    }
-    const typeAsClass = type;
-    const tagName = camel2title(endpointPath);
-    this.openApiModel.tags.push({
-      name: tagName,
-      description: (_b = type.docComment) == null ? void 0 : _b.description
-    });
-    const parser = new MethodParser(this.openApiModel);
-    parser.parseMethod(typeAsClass, endpointPath, "get", tagName);
-    parser.parseMethod(typeAsClass, endpointPath, "patch", tagName);
-    parser.parseMethod(typeAsClass, endpointPath, "post", tagName);
-    parser.parseMethod(typeAsClass, endpointPath, "put", tagName);
-    parser.parseMethod(typeAsClass, endpointPath, "delete", tagName);
-  }
-  getEndpointPath(type) {
-    var _a;
-    const restResourceAnnotation = type.annotations.find((element) => element.name.toLowerCase() === "restresource");
-    const urlMapping = (_a = restResourceAnnotation == null ? void 0 : restResourceAnnotation.elementValues) == null ? void 0 : _a.find(
-      (element) => element.key.toLowerCase() === "urlmapping"
-    );
-    if (!urlMapping) {
-      Logger.error(`Type does not contain urlMapping annotation ${type.name}`);
-      return null;
-    }
-    let endpointPath = urlMapping.value.replaceAll('"', "").replaceAll("'", "").replaceAll("/*", "/");
-    if (endpointPath.startsWith("/")) {
-      endpointPath = endpointPath.substring(1);
-    }
-    return endpointPath;
-  }
-}
-
-var __async$4 = (__this, __arguments, generator) => {
-  return new Promise((resolve, reject) => {
-    var fulfilled = (value) => {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var rejected = (value) => {
-      try {
-        step(generator.throw(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
-    step((generator = generator.apply(__this, __arguments)).next());
-  });
-};
-function openApi(fileBodies, config) {
-  return __async$4(this, null, function* () {
-    OpenApiSettings.build({
-      sourceDirectory: config.sourceDir,
-      outputDir: config.targetDir,
-      openApiFileName: config.fileName,
-      openApiTitle: config.title,
-      namespace: config.namespace,
-      version: config.apiVersion
-    });
-    const manifest = createManifest(new RawBodyParser(fileBodies), reflectionWithLogger);
-    TypesRepository.getInstance().populateAll(manifest.types);
-    const filteredTypes = filterByScopes(manifest);
-    const processor = new OpenApiDocsProcessor();
-    Transpiler.generate(filteredTypes, processor);
-    const generatedFiles = processor.fileBuilder().files();
-    yield _function.pipe(
-      writeFiles(generatedFiles, config.targetDir, (file) => {
-        Logger.logSingle(`${file.outputDocPath} processed.`, "green");
-      }),
-      TE__namespace.map(() => Logger.logSingle("\u2714\uFE0F Documentation generated successfully!")),
-      TE__namespace.mapError((error) => Logger.error(error))
-    )();
-    ErrorLogger.logErrors(filteredTypes);
-  });
-}
-function reflectionWithLogger(apexBundle) {
-  var _a;
-  const result = apexReflection.reflect(apexBundle.content);
-  if (result.error) {
-    Logger.error(`${apexBundle.filePath} - Parsing error ${(_a = result.error) == null ? void 0 : _a.message}`);
-  }
-  return result;
-}
-function filterByScopes(manifest) {
-  const filteredTypes = manifest.filteredByAccessModifierAndAnnotations([
-    "restresource",
-    "httpdelete",
-    "httpget",
-    "httppatch",
-    "httppost",
-    "httpput"
-  ]);
-  const filteredLogMessage = `Filtered ${manifest.types.length - filteredTypes.length} file(s), only keeping classes annotated as @RestResource.`;
-  Logger.logSingle(filteredLogMessage, "green");
-  Logger.logSingle(`Creating documentation for ${filteredTypes.length} file(s)`, "green");
-  return filteredTypes;
-}
-
-var __async$3 = (__this, __arguments, generator) => {
-  return new Promise((resolve, reject) => {
-    var fulfilled = (value) => {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var rejected = (value) => {
-      try {
-        step(generator.throw(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
-    step((generator = generator.apply(__this, __arguments)).next());
-  });
-};
-const APEX_FILE_EXTENSION = ".cls";
-class ApexFileReader {
-  /**
-   * Reads from .cls files and returns their raw body.
-   */
-  static processFiles(fileSystem, rootPath, includeMetadata) {
-    return __async$3(this, null, function* () {
-      const filePaths = yield this.getFilePaths(fileSystem, rootPath);
-      const apexFilePaths = filePaths.filter((filePath) => this.isApexFile(filePath));
-      const filePromises = apexFilePaths.map((filePath) => this.processFile(fileSystem, filePath, includeMetadata));
-      return Promise.all(filePromises);
-    });
-  }
-  static getFilePaths(fileSystem, rootPath) {
-    return __async$3(this, null, function* () {
-      const directoryContents = yield fileSystem.readDirectory(rootPath);
-      const paths = [];
-      for (const filePath of directoryContents) {
-        const currentPath = fileSystem.joinPath(rootPath, filePath);
-        if (yield fileSystem.isDirectory(currentPath)) {
-          paths.push(...yield this.getFilePaths(fileSystem, currentPath));
-        }
-        paths.push(currentPath);
-      }
-      return paths;
-    });
-  }
-  static processFile(fileSystem, filePath, includeMetadata) {
-    return __async$3(this, null, function* () {
-      const rawTypeContent = yield fileSystem.readFile(filePath);
-      const metadataPath = `${filePath}-meta.xml`;
-      let rawMetadataContent = null;
-      if (includeMetadata) {
-        rawMetadataContent = fileSystem.exists(metadataPath) ? yield fileSystem.readFile(metadataPath) : null;
-      }
-      return { filePath, content: rawTypeContent, metadataContent: rawMetadataContent };
-    });
-  }
-  static isApexFile(currentFile) {
-    return currentFile.endsWith(APEX_FILE_EXTENSION);
-  }
-}
-
-var __async$2 = (__this, __arguments, generator) => {
-  return new Promise((resolve, reject) => {
-    var fulfilled = (value) => {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var rejected = (value) => {
-      try {
-        step(generator.throw(value));
-      } catch (e) {
-        reject(e);
       }
-    };
-    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
-    step((generator = generator.apply(__this, __arguments)).next());
-  });
-};
-function stat(path2) {
-  return new Promise((resolve, reject) => {
-    fs__namespace.stat(path2, (err, stats) => {
-      if (err) {
-        reject(err);
-      } else {
-        resolve(stats);
-      }
-    });
-  });
-}
-function readdir(path2) {
-  return new Promise((resolve, reject) => {
-    fs__namespace.readdir(path2, (err, files) => {
-      if (err) {
-        reject(err);
-      } else {
-        resolve(files);
-      }
-    });
-  });
-}
-function readFile(path2) {
-  return new Promise((resolve, reject) => {
-    fs__namespace.readFile(path2, (err, data) => {
-      if (err) {
-        reject(err);
-      } else {
-        resolve(data.toString());
-      }
-    });
-  });
-}
-class DefaultFileSystem {
-  isDirectory(pathToRead) {
-    return __async$2(this, null, function* () {
-      const stats = yield stat(pathToRead);
-      return stats.isDirectory();
     });
   }
-  readDirectory(sourceDirectory) {
-    return readdir(sourceDirectory);
-  }
-  readFile(pathToRead) {
-    return readFile(pathToRead);
-  }
-  joinPath(...paths) {
-    return path__namespace.join(...paths);
-  }
-  exists(path2) {
-    return fs__namespace.existsSync(path2);
-  }
+  n.default = e;
+  return Object.freeze(n);
 }
 
-var __async$1 = (__this, __arguments, generator) => {
-  return new Promise((resolve, reject) => {
-    var fulfilled = (value) => {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var rejected = (value) => {
-      try {
-        step(generator.throw(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
-    step((generator = generator.apply(__this, __arguments)).next());
-  });
-};
-class Apexdocs {
-  /**
-   * Generates documentation out of Apex source files.
-   */
-  static generate(config) {
-    return __async$1(this, null, function* () {
-      Logger.logSingle(`Generating ${config.targetGenerator} documentation...`);
-      try {
-        const fileBodies = yield ApexFileReader.processFiles(
-          new DefaultFileSystem(),
-          config.sourceDir,
-          config.targetGenerator === "markdown" ? config.includeMetadata : false
-        );
-        switch (config.targetGenerator) {
-          case "markdown":
-            yield generateMarkdownDocumentation(fileBodies, config)();
-            break;
-          case "openapi":
-            yield openApi(fileBodies, config);
-            break;
-        }
-      } catch (error) {
-        Logger.logSingle(`\u274C An error occurred while generating the documentation: ${error}`, "red");
-      }
-    });
-  }
-}
-function generateMarkdownDocumentation(fileBodies, config) {
-  return _function.pipe(
-    generate(fileBodies, config),
-    TE__namespace.map(() => Logger.logSingle("\u2714\uFE0F Documentation generated successfully!")),
-    TE__namespace.mapLeft((error) => {
-      if (error._tag === "HookError") {
-        Logger.error("Error(s) occurred while processing hooks. Please review the following issues:");
-        Logger.error(error.error);
-        return;
-      }
-      if (error._tag === "FileWritingError") {
-        Logger.error(error.message);
-        Logger.error(error.error);
-        return;
-      }
-      const errorMessages = [
-        "Error(s) occurred while parsing files. Please review the following issues:",
-        ...error.errors.map(formatReflectionError)
-      ].join("\n");
-      Logger.error(errorMessages);
-    })
-  );
-}
-function formatReflectionError(error) {
-  return `Source file: ${error.file}
-${error.message}
-`;
-}
+var yargs__namespace = /*#__PURE__*/_interopNamespaceDefault(yargs);
+var E__namespace = /*#__PURE__*/_interopNamespaceDefault(E);
 
 const markdownOptions = {
   sourceDir: {
@@ -3097,40 +51,45 @@ const markdownOptions = {
   targetDir: {
     type: "string",
     alias: "t",
-    default: defaults.defaults.targetDir,
+    default: logger$1.markdownDefaults.targetDir,
     describe: "The directory location where documentation will be generated to."
   },
   scope: {
     type: "string",
     array: true,
     alias: "p",
-    default: defaults.defaults.scope,
+    default: logger$1.markdownDefaults.scope,
     describe: "A list of scopes to document. Values should be separated by a space, e.g --scope global public namespaceaccessible. Annotations are supported and should be passed lowercased and without the @ symbol, e.g. namespaceaccessible auraenabled."
   },
   defaultGroupName: {
     type: "string",
-    default: defaults.defaults.defaultGroupName,
+    default: logger$1.markdownDefaults.defaultGroupName,
     describe: "Defines the @group name to be used when a file does not specify it."
   },
   namespace: {
     type: "string",
     describe: "The package namespace, if any. If provided, it will be added to the generated files."
   },
-  sortMembersAlphabetically: {
+  sortAlphabetically: {
     type: "boolean",
-    describe: "Whether to sort members alphabetically.",
-    default: defaults.defaults.sortMembersAlphabetically
+    describe: "Whether to sort files and members alphabetically.",
+    default: logger$1.markdownDefaults.sortAlphabetically
   },
   includeMetadata: {
     type: "boolean",
     describe: "Whether to include the file's meta.xml information: Whether it is active and and the API version",
-    default: defaults.defaults.includeMetadata
+    default: logger$1.markdownDefaults.includeMetadata
   },
   linkingStrategy: {
     type: "string",
     describe: "The strategy to use when linking to other documentation pages.",
     choices: ["relative", "no-link", "none"],
-    default: defaults.defaults.linkingStrategy
+    default: logger$1.markdownDefaults.linkingStrategy
+  },
+  referenceGuideTitle: {
+    type: "string",
+    describe: "The title of the reference guide.",
+    default: logger$1.markdownDefaults.referenceGuideTitle
   }
 };
 
@@ -3144,12 +103,12 @@ const openApiOptions = {
   targetDir: {
     type: "string",
     alias: "t",
-    default: defaults.defaults.targetDir,
+    default: logger$1.markdownDefaults.targetDir,
     describe: "The directory location where the OpenApi file will be generated."
   },
   fileName: {
     type: "string",
-    default: "openapi",
+    default: logger$1.openApiDefaults.fileName,
     describe: "The name of the OpenApi file to be generated."
   },
   namespace: {
@@ -3158,12 +117,12 @@ const openApiOptions = {
   },
   title: {
     type: "string",
-    default: "Apex REST API",
+    default: logger$1.openApiDefaults.title,
     describe: "The title of the OpenApi file."
   },
   apiVersion: {
     type: "string",
-    default: "1.0.0",
+    default: logger$1.openApiDefaults.apiVersion,
     describe: "The version of the OpenApi file."
   }
 };
@@ -3207,6 +166,9 @@ var __async = (__this, __arguments, generator) => {
     step((generator = generator.apply(__this, __arguments)).next());
   });
 };
+const configOnlyDefaults = {
+  excludeTags: []
+};
 function _extractConfig() {
   return cosmiconfig.cosmiconfig("apexdocs", {
     loaders: {
@@ -3230,15 +192,32 @@ function extractArgs() {
     const config = yield _extractConfig();
     const cliArgs = _extractYargs(config);
     const commandName = cliArgs._[0];
-    return __spreadProps(__spreadValues(__spreadValues({}, config == null ? void 0 : config.config), cliArgs), { targetGenerator: commandName });
+    const mergedConfig = __spreadProps(__spreadValues(__spreadValues({}, config == null ? void 0 : config.config), cliArgs), { targetGenerator: commandName });
+    if (mergedConfig.targetGenerator === "markdown") {
+      return __spreadValues(__spreadValues({}, configOnlyDefaults), mergedConfig);
+    } else {
+      return mergedConfig;
+    }
   });
 }
 
+const logger = new logger$1.StdOutLogger();
 function main() {
-  function catchError(error) {
-    console.error(error);
+  function parseResult(result) {
+    E__namespace.match(
+      (error) => {
+        logger.error(`\u274C An error occurred while generating the documentation: ${error}`);
+        process.exit(1);
+      },
+      (successMessage) => {
+        logger.logSingle(successMessage);
+      }
+    )(result);
+  }
+  function catchUnexpectedError(error) {
+    logger.error(`\u274C An unexpected error occurred: ${error.message}`);
     process.exit(1);
   }
-  extractArgs().then((config) => Apexdocs.generate(config).catch(catchError)).catch(catchError);
+  extractArgs().then((config) => logger$1.Apexdocs.generate(config, logger).then(parseResult)).catch(catchUnexpectedError);
 }
 main();