@bliztek/mdx-utils 1.0.0 → 2.0.0

package/dist/index.d.cts

@@ -1,42 +1 @@
-type TableOfContentsEntry = {
-    title: string;
-    link: string;
-};
-type TableOfContents = TableOfContentsEntry[];
-interface ReadTimeOptions {
-    /** Words per minute. Defaults to 238. */
-    wordsPerMinute?: number;
-}
-interface ReadTimeResult {
-    /** Estimated read time in minutes (minimum 1). */
-    minutes: number;
-    /** Total word count after stripping MDX/JSX syntax. */
-    words: number;
-}
-interface GetContentSlugsOptions {
-    /** File extensions to include. Defaults to `[".mdx"]`. */
-    extensions?: string[];
-    /** Recursively search subdirectories. Defaults to `false`. */
-    recursive?: boolean;
-}
-
-/**
- * Strip MDX/markdown syntax from content, returning plain text.
- * Removes export blocks, import statements, JSX tags, and markdown
- * formatting characters. Useful for generating excerpts, search
- * indexes, or OpenGraph descriptions from raw MDX.
- */
-declare function stripMdxSyntax(content: string): string;
-/**
- * Calculate estimated read time for MDX/markdown content.
- * Strips export blocks, import statements, JSX tags, and markdown syntax
- * before counting words.
- */
-declare function calculateReadTime(content: string, options?: ReadTimeOptions): ReadTimeResult;
-/**
- * Sort items by date in descending order (newest first).
- * Returns a new array without mutating the original.
- */
-declare function sortByDateDescending<T>(items: T[], getDate: (item: T) => string): T[];
-
-export { type GetContentSlugsOptions, type ReadTimeOptions, type ReadTimeResult, type TableOfContents, type TableOfContentsEntry, calculateReadTime, sortByDateDescending, stripMdxSyntax };
+export { F as FrontmatterSchema, G as GetContentSlugsOptions, d as MdxEntry, R as ReadTimeOptions, e as ReadTimeResult, T as TableOfContents, f as TableOfContentsEntry, g as calculateReadTime, s as sortByDateDescending, h as stripMdxSyntax } from './index-is67XHX5.cjs';

package/dist/index.d.ts

@@ -1,42 +1 @@
-type TableOfContentsEntry = {
-    title: string;
-    link: string;
-};
-type TableOfContents = TableOfContentsEntry[];
-interface ReadTimeOptions {
-    /** Words per minute. Defaults to 238. */
-    wordsPerMinute?: number;
-}
-interface ReadTimeResult {
-    /** Estimated read time in minutes (minimum 1). */
-    minutes: number;
-    /** Total word count after stripping MDX/JSX syntax. */
-    words: number;
-}
-interface GetContentSlugsOptions {
-    /** File extensions to include. Defaults to `[".mdx"]`. */
-    extensions?: string[];
-    /** Recursively search subdirectories. Defaults to `false`. */
-    recursive?: boolean;
-}
-
-/**
- * Strip MDX/markdown syntax from content, returning plain text.
- * Removes export blocks, import statements, JSX tags, and markdown
- * formatting characters. Useful for generating excerpts, search
- * indexes, or OpenGraph descriptions from raw MDX.
- */
-declare function stripMdxSyntax(content: string): string;
-/**
- * Calculate estimated read time for MDX/markdown content.
- * Strips export blocks, import statements, JSX tags, and markdown syntax
- * before counting words.
- */
-declare function calculateReadTime(content: string, options?: ReadTimeOptions): ReadTimeResult;
-/**
- * Sort items by date in descending order (newest first).
- * Returns a new array without mutating the original.
- */
-declare function sortByDateDescending<T>(items: T[], getDate: (item: T) => string): T[];
-
-export { type GetContentSlugsOptions, type ReadTimeOptions, type ReadTimeResult, type TableOfContents, type TableOfContentsEntry, calculateReadTime, sortByDateDescending, stripMdxSyntax };
+export { F as FrontmatterSchema, G as GetContentSlugsOptions, d as MdxEntry, R as ReadTimeOptions, e as ReadTimeResult, T as TableOfContents, f as TableOfContentsEntry, g as calculateReadTime, s as sortByDateDescending, h as stripMdxSyntax } from './index-is67XHX5.js';

package/dist/node.cjs

@@ -30,15 +30,19 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/node.ts
 var node_exports = {};
 __export(node_exports, {
+  MdxValidationError: () => MdxValidationError,
   calculateReadTime: () => calculateReadTime,
+  collectRedirects: () => collectRedirects,
+  createMdxCollection: () => createMdxCollection,
+  defaultParseFrontmatter: () => defaultParseFrontmatter,
   getContentSlugs: () => getContentSlugs,
   readMdxFile: () => readMdxFile,
   sortByDateDescending: () => sortByDateDescending,
   stripMdxSyntax: () => stripMdxSyntax
 });
 module.exports = __toCommonJS(node_exports);
-var import_promises = require("fs/promises");
-var import_path = __toESM(require("path"), 1);
+var import_promises2 = require("fs/promises");
+var import_node_path2 = __toESM(require("path"), 1);
 
 // src/index.ts
 var DEFAULT_WPM = 238;
@@ -60,12 +64,330 @@ function sortByDateDescending(items, getDate) {
   );
 }
 
+// src/collection.ts
+var import_promises = require("fs/promises");
+var import_node_path = __toESM(require("path"), 1);
+
+// src/frontmatter.ts
+function defaultParseFrontmatter(raw) {
+  const match = raw.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!match) return {};
+  const lines = match[1].split(/\r?\n/);
+  const result = {};
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (/^\s*(#|$)/.test(line)) {
+      i++;
+      continue;
+    }
+    const kv = line.match(/^(\s*)([A-Za-z_][\w-]*)\s*:\s*(.*)$/);
+    if (!kv) {
+      i++;
+      continue;
+    }
+    const key = kv[2];
+    const rawValue = kv[3].trim();
+    if (rawValue === "") {
+      const items = [];
+      let j = i + 1;
+      while (j < lines.length) {
+        const next = lines[j];
+        if (/^\s*$/.test(next)) {
+          j++;
+          continue;
+        }
+        const blockItem = next.match(/^\s+-\s+(.*)$/);
+        if (!blockItem) break;
+        items.push(parseScalar(blockItem[1].trim()));
+        j++;
+      }
+      if (items.length > 0) {
+        result[key] = items;
+        i = j;
+        continue;
+      }
+      result[key] = "";
+      i++;
+      continue;
+    }
+    if (rawValue.startsWith("[") && rawValue.endsWith("]")) {
+      const inner = rawValue.slice(1, -1).trim();
+      result[key] = inner === "" ? [] : splitInlineArray(inner).map(parseScalar);
+      i++;
+      continue;
+    }
+    result[key] = parseScalar(rawValue);
+    i++;
+  }
+  return result;
+}
+function parseScalar(value) {
+  if (value.length >= 2) {
+    const first = value[0];
+    const last = value[value.length - 1];
+    if (first === '"' && last === '"' || first === "'" && last === "'") {
+      return value.slice(1, -1);
+    }
+  }
+  return value;
+}
+function splitInlineArray(inner) {
+  const out = [];
+  let buf = "";
+  let quote = null;
+  for (let i = 0; i < inner.length; i++) {
+    const ch = inner[i];
+    if (quote) {
+      buf += ch;
+      if (ch === quote) quote = null;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      buf += ch;
+      continue;
+    }
+    if (ch === ",") {
+      out.push(buf.trim());
+      buf = "";
+      continue;
+    }
+    buf += ch;
+  }
+  if (buf.trim() !== "") out.push(buf.trim());
+  return out;
+}
+
+// src/errors.ts
+var MAX_INLINE_ISSUES = 10;
+function formatMessage(issues) {
+  if (issues.length === 0) {
+    return "MdxValidationError: no issues (this is a bug \u2014 do not throw with an empty list)";
+  }
+  const head = `MdxValidationError: ${issues.length} issue${issues.length === 1 ? "" : "s"} found in frontmatter`;
+  const shown = issues.slice(0, MAX_INLINE_ISSUES);
+  const lines = shown.map(
+    (issue) => `  - ${issue.filePath} @ ${issue.path}: ${issue.message}`
+  );
+  if (issues.length > shown.length) {
+    lines.push(`  ... and ${issues.length - shown.length} more`);
+  }
+  return [head, ...lines].join("\n");
+}
+var MdxValidationError = class extends Error {
+  constructor(issues) {
+    super(formatMessage(issues));
+    this.name = "MdxValidationError";
+    this.issues = issues;
+  }
+};
+
+// src/collection.ts
+async function walkCollection(rootAbs, namespaceDepth) {
+  const dirents = await (0, import_promises.readdir)(rootAbs, {
+    withFileTypes: true,
+    recursive: true
+  });
+  const files = [];
+  for (const dirent of dirents) {
+    if (dirent.isDirectory()) continue;
+    if (!dirent.name.endsWith(".mdx")) continue;
+    const parentPath = dirent.parentPath ?? rootAbs;
+    const relativeDir = import_node_path.default.relative(rootAbs, parentPath);
+    const segments = relativeDir === "" ? [] : relativeDir.split(import_node_path.default.sep);
+    if (segments.length !== namespaceDepth) {
+      const filePath = import_node_path.default.join(parentPath, dirent.name);
+      throw new Error(
+        `[mdx-utils] File ${filePath} is at depth ${segments.length} but the collection declares namespaceDepth=${namespaceDepth}. Move the file or adjust namespaceDepth.`
+      );
+    }
+    files.push({
+      namespace: segments.join("/"),
+      slug: dirent.name.slice(0, -".mdx".length),
+      filePath: import_node_path.default.join(parentPath, dirent.name)
+    });
+  }
+  return files;
+}
+function stripFrontmatterBlock(raw) {
+  const match = raw.match(/^---\r?\n[\s\S]*?\r?\n---\r?\n?/);
+  return match ? raw.slice(match[0].length) : raw;
+}
+function sortEntries(entries) {
+  const withDate = [];
+  const withoutDate = [];
+  for (const entry of entries) {
+    const meta = entry.metadata;
+    const publishedAt = meta?.publishedAt;
+    if (typeof publishedAt === "string") {
+      const ts = new Date(publishedAt).getTime();
+      if (!Number.isNaN(ts)) {
+        withDate.push({ entry, ts });
+        continue;
+      }
+    }
+    withoutDate.push(entry);
+  }
+  withDate.sort((a, b) => b.ts - a.ts);
+  return [...withDate.map((x) => x.entry), ...withoutDate];
+}
+function extractIssues(filePath, error) {
+  if (error && typeof error === "object" && "issues" in error && Array.isArray(error.issues)) {
+    const raw = error.issues;
+    const mapped = [];
+    for (const entry of raw) {
+      const pathValue = entry.path;
+      const dotted = Array.isArray(pathValue) ? pathValue.join(".") : typeof pathValue === "string" ? pathValue : "(root)";
+      const message2 = typeof entry.message === "string" ? entry.message : String(entry);
+      mapped.push({ filePath, path: dotted || "(root)", message: message2 });
+    }
+    if (mapped.length > 0) return mapped;
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  return [{ filePath, path: "(root)", message }];
+}
+function createMdxCollection(options) {
+  const {
+    root,
+    namespaceDepth = 0,
+    frontmatterSchema,
+    parseFrontmatter = defaultParseFrontmatter,
+    wordsPerMinute
+  } = options;
+  const rootAbs = import_node_path.default.resolve(root);
+  let entriesPromise = null;
+  async function loadEntries() {
+    const files = await walkCollection(rootAbs, namespaceDepth);
+    const loaded = await Promise.all(
+      files.map(async (file) => {
+        const raw = await (0, import_promises.readFile)(file.filePath, "utf-8");
+        const metadata = parseFrontmatter(raw);
+        const body = stripFrontmatterBlock(raw);
+        const { minutes } = calculateReadTime(body, { wordsPerMinute });
+        return {
+          namespace: file.namespace,
+          slug: file.slug,
+          metadata,
+          readTime: minutes,
+          tableOfContents: void 0,
+          filePath: file.filePath
+        };
+      })
+    );
+    return sortEntries(loaded);
+  }
+  function getAll() {
+    if (!entriesPromise) {
+      entriesPromise = loadEntries().catch((err) => {
+        entriesPromise = null;
+        throw err;
+      });
+    }
+    return entriesPromise;
+  }
+  async function getAllByNamespace(namespace) {
+    const all = await getAll();
+    return all.filter((entry) => entry.namespace === namespace);
+  }
+  async function get(args) {
+    const targetNamespace = args.namespace ?? "";
+    const all = await getAll();
+    return all.find(
+      (entry) => entry.namespace === targetNamespace && entry.slug === args.slug
+    ) ?? null;
+  }
+  async function resolveRelated(namespace, slugs) {
+    const all = await getAll();
+    const inNamespace = new Map(
+      all.filter((entry) => entry.namespace === namespace).map((entry) => [entry.slug, entry])
+    );
+    const resolved = [];
+    for (const slug of slugs) {
+      const entry = inNamespace.get(slug);
+      if (entry) {
+        resolved.push(entry);
+      } else {
+        console.warn(
+          `[mdx-utils] resolveRelated: no entry for "${slug}" in namespace "${namespace}"`
+        );
+      }
+    }
+    return resolved;
+  }
+  async function validate() {
+    if (!frontmatterSchema) return;
+    const all = await getAll();
+    const issues = [];
+    for (const entry of all) {
+      try {
+        frontmatterSchema.parse(entry.metadata);
+      } catch (err) {
+        issues.push(...extractIssues(entry.filePath, err));
+      }
+    }
+    if (issues.length > 0) {
+      throw new MdxValidationError(issues);
+    }
+  }
+  function invalidate() {
+    entriesPromise = null;
+  }
+  return {
+    getAll,
+    getAllByNamespace,
+    get,
+    resolveRelated,
+    validate,
+    invalidate
+  };
+}
+
+// src/redirects.ts
+function applyTokens(template, namespace, slug) {
+  return template.replace(/\{namespace\}/g, namespace).replace(/\{slug\}/g, slug);
+}
+async function collectRedirects(options) {
+  const {
+    root,
+    namespaceDepth = 0,
+    basePath,
+    permanent = true,
+    aliasField = "aliases"
+  } = options;
+  const collection = createMdxCollection({ root, namespaceDepth });
+  const entries = await collection.getAll();
+  const redirects = [];
+  const sourceOwners = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const meta = entry.metadata;
+    const rawAliases = meta[aliasField];
+    if (!Array.isArray(rawAliases)) continue;
+    const destination = applyTokens(basePath, entry.namespace, entry.slug);
+    for (const alias of rawAliases) {
+      if (typeof alias !== "string" || alias === "") continue;
+      const source = applyTokens(basePath, entry.namespace, alias);
+      if (source === destination) continue;
+      const existing = sourceOwners.get(source);
+      if (existing && existing !== entry.filePath) {
+        console.warn(
+          `[mdx-utils] collectRedirects: duplicate alias "${alias}" defined in both ${existing} and ${entry.filePath}. Next.js will pick the first match.`
+        );
+      } else {
+        sourceOwners.set(source, entry.filePath);
+      }
+      redirects.push({ source, destination, permanent });
+    }
+  }
+  return redirects;
+}
+
 // src/node.ts
 var DEFAULT_EXTENSIONS = [".mdx"];
 async function getContentSlugs(dirPath, options) {
   const extensions = options?.extensions ?? DEFAULT_EXTENSIONS;
   const recursive = options?.recursive ?? false;
-  const dirents = await (0, import_promises.readdir)(dirPath, {
+  const dirents = await (0, import_promises2.readdir)(dirPath, {
     withFileTypes: true,
     recursive
   });
@@ -74,16 +396,20 @@ async function getContentSlugs(dirPath, options) {
   ).map((dirent) => {
     const slug = dirent.name.substring(0, dirent.name.lastIndexOf("."));
     if (!recursive || !dirent.parentPath) return slug;
-    const relativePath = import_path.default.relative(dirPath, dirent.parentPath);
-    return relativePath ? import_path.default.join(relativePath, slug) : slug;
+    const relativePath = import_node_path2.default.relative(dirPath, dirent.parentPath);
+    return relativePath ? import_node_path2.default.join(relativePath, slug) : slug;
   });
 }
 async function readMdxFile(filePath) {
-  return (0, import_promises.readFile)(filePath, "utf-8");
+  return (0, import_promises2.readFile)(filePath, "utf-8");
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  MdxValidationError,
   calculateReadTime,
+  collectRedirects,
+  createMdxCollection,
+  defaultParseFrontmatter,
   getContentSlugs,
   readMdxFile,
   sortByDateDescending,

package/dist/node.d.cts

@@ -1,5 +1,78 @@
-import { GetContentSlugsOptions } from './index.cjs';
-export { ReadTimeOptions, ReadTimeResult, TableOfContents, TableOfContentsEntry, calculateReadTime, sortByDateDescending, stripMdxSyntax } from './index.cjs';
+import { C as CreateMdxCollectionOptions, M as MdxCollection, a as CollectRedirectsOptions, N as NextRedirect, b as MdxValidationIssue, G as GetContentSlugsOptions } from './index-is67XHX5.cjs';
+export { F as FrontmatterSchema, c as MdxCollectionGetArgs, d as MdxEntry, R as ReadTimeOptions, e as ReadTimeResult, T as TableOfContents, f as TableOfContentsEntry, g as calculateReadTime, s as sortByDateDescending, h as stripMdxSyntax } from './index-is67XHX5.cjs';
+
+declare function createMdxCollection<TFrontmatter = Record<string, unknown>>(options: CreateMdxCollectionOptions<TFrontmatter>): MdxCollection<TFrontmatter>;
+
+/**
+ * Walk a collection and emit Next.js-shaped redirects from each entry's
+ * `aliases` frontmatter field. Designed to plug straight into
+ * `next.config.ts`:
+ *
+ * ```ts
+ * export default {
+ *   async redirects() {
+ *     return collectRedirects({
+ *       root: "content/games",
+ *       namespaceDepth: 1,
+ *       basePath: "/games/{namespace}/guides/{slug}",
+ *     });
+ *   },
+ * };
+ * ```
+ *
+ * Entries without an `aliases` field contribute nothing. Non-array
+ * values in the field are silently skipped — content-shape errors
+ * should never break `next.config`.
+ */
+declare function collectRedirects(options: CollectRedirectsOptions): Promise<NextRedirect[]>;
+
+/**
+ * Minimal built-in frontmatter parser.
+ *
+ * This is deliberately *not* a full YAML parser. It handles the subset
+ * used by blog and docs content and nothing more:
+ *
+ *   - A `---`-delimited block at the very start of the file
+ *   - `key: value` pairs with unquoted or quoted string values
+ *   - Inline arrays: `tags: [a, b, c]`
+ *   - Block arrays: `aliases:\n  - old-slug\n  - older-slug`
+ *   - Blank lines and `# comments` inside the block
+ *
+ * All scalar values are returned as strings — no type coercion for
+ * numbers, booleans, or dates. Consumers who need coercion should run
+ * the result through a schema (`frontmatterSchema`) or swap in a real
+ * YAML parser via `parseFrontmatter`.
+ *
+ * Stability contract:
+ *   - Expanding the supported subset (e.g. adding boolean coercion) is
+ *     a non-breaking minor change.
+ *   - Changing the *output shape* of already-supported inputs is a
+ *     breaking change.
+ *
+ * Consumers who want to extend rather than replace the default can
+ * import it directly:
+ *
+ * ```ts
+ * import { defaultParseFrontmatter } from "@bliztek/mdx-utils/node";
+ * const wrapped = (raw: string) => {
+ *   const base = defaultParseFrontmatter(raw);
+ *   // ... post-process base ...
+ *   return base;
+ * };
+ * ```
+ */
+declare function defaultParseFrontmatter(raw: string): Record<string, unknown>;
+
+/**
+ * Thrown by `MdxCollection.validate()` when one or more files fail
+ * schema validation. The full list of issues is preserved on `.issues`
+ * so consumers can render their own output instead of parsing the
+ * message string.
+ */
+declare class MdxValidationError extends Error {
+    readonly issues: MdxValidationIssue[];
+    constructor(issues: MdxValidationIssue[]);
+}
 
 /**
  * Get all content file slugs from a directory.
@@ -15,4 +88,4 @@ declare function getContentSlugs(dirPath: string, options?: GetContentSlugsOptio
  */
 declare function readMdxFile(filePath: string): Promise<string>;
 
-export { GetContentSlugsOptions, getContentSlugs, readMdxFile };
+export { CollectRedirectsOptions, CreateMdxCollectionOptions, GetContentSlugsOptions, MdxCollection, MdxValidationError, MdxValidationIssue, NextRedirect, collectRedirects, createMdxCollection, defaultParseFrontmatter, getContentSlugs, readMdxFile };

package/dist/node.d.ts

@@ -1,5 +1,78 @@
-import { GetContentSlugsOptions } from './index.js';
-export { ReadTimeOptions, ReadTimeResult, TableOfContents, TableOfContentsEntry, calculateReadTime, sortByDateDescending, stripMdxSyntax } from './index.js';
+import { C as CreateMdxCollectionOptions, M as MdxCollection, a as CollectRedirectsOptions, N as NextRedirect, b as MdxValidationIssue, G as GetContentSlugsOptions } from './index-is67XHX5.js';
+export { F as FrontmatterSchema, c as MdxCollectionGetArgs, d as MdxEntry, R as ReadTimeOptions, e as ReadTimeResult, T as TableOfContents, f as TableOfContentsEntry, g as calculateReadTime, s as sortByDateDescending, h as stripMdxSyntax } from './index-is67XHX5.js';
+
+declare function createMdxCollection<TFrontmatter = Record<string, unknown>>(options: CreateMdxCollectionOptions<TFrontmatter>): MdxCollection<TFrontmatter>;
+
+/**
+ * Walk a collection and emit Next.js-shaped redirects from each entry's
+ * `aliases` frontmatter field. Designed to plug straight into
+ * `next.config.ts`:
+ *
+ * ```ts
+ * export default {
+ *   async redirects() {
+ *     return collectRedirects({
+ *       root: "content/games",
+ *       namespaceDepth: 1,
+ *       basePath: "/games/{namespace}/guides/{slug}",
+ *     });
+ *   },
+ * };
+ * ```
+ *
+ * Entries without an `aliases` field contribute nothing. Non-array
+ * values in the field are silently skipped — content-shape errors
+ * should never break `next.config`.
+ */
+declare function collectRedirects(options: CollectRedirectsOptions): Promise<NextRedirect[]>;
+
+/**
+ * Minimal built-in frontmatter parser.
+ *
+ * This is deliberately *not* a full YAML parser. It handles the subset
+ * used by blog and docs content and nothing more:
+ *
+ *   - A `---`-delimited block at the very start of the file
+ *   - `key: value` pairs with unquoted or quoted string values
+ *   - Inline arrays: `tags: [a, b, c]`
+ *   - Block arrays: `aliases:\n  - old-slug\n  - older-slug`
+ *   - Blank lines and `# comments` inside the block
+ *
+ * All scalar values are returned as strings — no type coercion for
+ * numbers, booleans, or dates. Consumers who need coercion should run
+ * the result through a schema (`frontmatterSchema`) or swap in a real
+ * YAML parser via `parseFrontmatter`.
+ *
+ * Stability contract:
+ *   - Expanding the supported subset (e.g. adding boolean coercion) is
+ *     a non-breaking minor change.
+ *   - Changing the *output shape* of already-supported inputs is a
+ *     breaking change.
+ *
+ * Consumers who want to extend rather than replace the default can
+ * import it directly:
+ *
+ * ```ts
+ * import { defaultParseFrontmatter } from "@bliztek/mdx-utils/node";
+ * const wrapped = (raw: string) => {
+ *   const base = defaultParseFrontmatter(raw);
+ *   // ... post-process base ...
+ *   return base;
+ * };
+ * ```
+ */
+declare function defaultParseFrontmatter(raw: string): Record<string, unknown>;
+
+/**
+ * Thrown by `MdxCollection.validate()` when one or more files fail
+ * schema validation. The full list of issues is preserved on `.issues`
+ * so consumers can render their own output instead of parsing the
+ * message string.
+ */
+declare class MdxValidationError extends Error {
+    readonly issues: MdxValidationIssue[];
+    constructor(issues: MdxValidationIssue[]);
+}
 
 /**
  * Get all content file slugs from a directory.
@@ -15,4 +88,4 @@ declare function getContentSlugs(dirPath: string, options?: GetContentSlugsOptio
  */
 declare function readMdxFile(filePath: string): Promise<string>;
 
-export { GetContentSlugsOptions, getContentSlugs, readMdxFile };
+export { CollectRedirectsOptions, CreateMdxCollectionOptions, GetContentSlugsOptions, MdxCollection, MdxValidationError, MdxValidationIssue, NextRedirect, collectRedirects, createMdxCollection, defaultParseFrontmatter, getContentSlugs, readMdxFile };