@fullstackdatasolutions/articles 0.12.0 → 1.0.0

package/dist/server.d.ts

@@ -1,4 +1,4 @@
-import { ComponentType } from 'react';
+import { ComponentType, ReactNode } from 'react';
 import { Metadata, MetadataRoute } from 'next';
 import * as react_jsx_runtime from 'react/jsx-runtime';
 
@@ -23,9 +23,12 @@ interface Article {
     lastmod?: string;
     author: string;
     authors?: string[];
+    authorSlug?: string;
+    authorAvatar?: string;
     category: string;
     categories: string[];
     readTime: string;
+    wordCount?: number;
     featuredImage: string;
     tags?: string[];
     content?: string;
@@ -39,7 +42,65 @@ interface Article {
     canonicalUrl?: string;
     articleType?: string;
     series?: string;
+    /**
+     * Machine-safe series identifier (Phase 27F) - separate from the
+     * label-only `series` string, which stays supported unchanged for
+     * consumers who only set it. `seriesSlug`/`seriesOrder` turn `series` into
+     * a navigable reader journey via `getArticlesBySeries`/
+     * `getAdjacentArticlesInSeries`. Both optional; omitted on every article
+     * reproduces pre-27F behavior exactly.
+     */
+    seriesSlug?: string;
+    /** Position within `seriesSlug`, ascending. Ties/omissions fall back to date order (see `getArticlesBySeries`). */
+    seriesOrder?: number;
     aiCrawl?: boolean;
+    /**
+     * Discovery metadata overrides (Phase 27F), all optional and additive.
+     * `searchTitle`/`searchDescription` feed `generateArticleMetadata`'s
+     * `<title>`/meta description ONLY - canonical URLs, JSON-LD, RSS, and
+     * `ArticleCard` keep reading `title`/`excerpt` unchanged. `socialTitle`/
+     * `socialDescription`/`socialImage` feed Open Graph/Twitter Card output
+     * ONLY, falling back to `title`/`excerpt`/`featuredImage`. See
+     * `resolveSearchMetadata`/`resolveSocialMetadata` in `seoUtils.ts` for the
+     * exact fallback/sanitization rules.
+     */
+    searchTitle?: string;
+    searchDescription?: string;
+    socialTitle?: string;
+    socialDescription?: string;
+    socialImage?: string;
+    /**
+     * References an app-owned CTA/offer by opaque ID (Phase 27F). The package
+     * never interprets `actionId` - it doesn't know about forms, email
+     * providers, or analytics vendors. The consuming app looks `actionId` up
+     * in its own registry when rendering a detail-page slot (see
+     * `ArticleContent`'s `afterHero`/`afterIntro`/`midContent`/`afterContent`
+     * props); an unmatched ID must render nothing, never throw.
+     */
+    primaryAction?: {
+        actionId: string;
+    };
+}
+/**
+ * A "start here" curated reader journey that can cross series/categories -
+ * a distinct primitive from the label-only `series` field/`seriesSlug`
+ * pair (Phase 27F). Configured via `ArticlesConfig.paths`, keyed by an
+ * app-chosen path key. `articles` is an ordered list of slugs; every
+ * referenced slug must exist and not be `draft: true` - enforced by
+ * `validateArticles`, not silently at render time.
+ */
+interface PathDefinition {
+    /** Display name, e.g. "New GM Starter Path". */
+    name: string;
+    /** One-sentence value proposition shown on the path's landing/step UI. */
+    promise: string;
+    /** Ordered article slugs making up the journey. */
+    articles: string[];
+    /** The one next action offered once a reader completes the path. */
+    nextAction: {
+        label: string;
+        href: string;
+    };
 }
 interface CategoryInfo {
     name: string;
@@ -64,6 +125,23 @@ interface AuthorSocial {
     newsletter?: string;
     other?: Record<string, string>;
 }
+/**
+ * One headed block of structured long-form content (used by
+ * `AuthorProfile.originStory`). An array of these, not a single HTML blob,
+ * so consuming apps can render/style each block themselves rather than
+ * `dangerouslySetInnerHTML`-ing raw markup.
+ */
+interface RichTextSection {
+    heading?: string;
+    paragraphs: string[];
+}
+type RichText = RichTextSection[];
+/** A single sourceable claim used by `AuthorProfile.proof`. */
+interface ProofItem {
+    claim: string;
+    source?: string;
+    url?: string;
+}
 interface AuthorProfile {
     name: string;
     slug: string;
@@ -71,12 +149,88 @@ interface AuthorProfile {
     avatar?: string;
     url?: string;
     social?: AuthorSocial;
+    /** Short one-line audience promise, e.g. "Helping new GMs run confident first sessions." Optional, additive - omitted fields never change existing rendering. */
+    promise?: string;
+    /** Structured long-form origin story - see `RichText`/`RichTextSection`. */
+    originStory?: RichText;
+    /** Who this author's content/work is for, e.g. "New game masters", "Streaming DMs". */
+    servesWho?: string[];
+    /** Core beliefs/approach statements. */
+    principles?: string[];
+    /**
+     * Experience/credential claims (e.g. "10+ years running published campaigns").
+     * Intentionally never included in Person JSON-LD - unverifiable claims don't
+     * belong in structured data (see `getPersonSchema`/`getPersonSchemas`).
+     */
+    credentials?: string[];
+    /** Concrete, sourceable proof points. */
+    proof?: ProofItem[];
+    /** Primary call-to-action rendered on the author's page. */
+    primaryCta?: {
+        label: string;
+        href: string;
+    };
 }
 interface BreadcrumbItem {
     name: string;
     url?: string;
 }
 
+type ArticleEventName = 'article_viewed' | 'meaningful_read' | 'author_clicked' | 'cta_viewed' | 'cta_clicked' | 'shared' | 'related_article_clicked' | 'path_step_advanced';
+interface ArticleEventBase<Name extends ArticleEventName> {
+    name: Name;
+    /** `Date.now()` at emit time. */
+    timestamp: number;
+}
+interface ArticleViewedEvent extends ArticleEventBase<'article_viewed'> {
+    articleSlug: string;
+    category?: string;
+    seriesSlug?: string;
+}
+/** Fired once per view after the reader has spent roughly half the article's estimated read time on the page (see `ArticleViewTracker`). */
+interface MeaningfulReadEvent extends ArticleEventBase<'meaningful_read'> {
+    articleSlug: string;
+}
+interface AuthorClickedEvent extends ArticleEventBase<'author_clicked'> {
+    articleSlug: string;
+    authorSlug: string;
+}
+/** `ctaId` is `primaryAction.actionId`, an `AuthorProfile.primaryCta` slug, or a `PathDefinition` key - always an app-chosen ID, never label text. */
+interface CtaViewedEvent extends ArticleEventBase<'cta_viewed'> {
+    ctaId: string;
+    articleSlug?: string;
+}
+interface CtaClickedEvent extends ArticleEventBase<'cta_clicked'> {
+    ctaId: string;
+    articleSlug?: string;
+}
+interface SharedEvent extends ArticleEventBase<'shared'> {
+    articleSlug: string;
+    /** Share channel key, e.g. `'linkedin'`, `'copy-link'` - never the shared URL/message text. */
+    channel: string;
+}
+interface RelatedArticleClickedEvent extends ArticleEventBase<'related_article_clicked'> {
+    fromSlug: string;
+    toSlug: string;
+    source: 'path' | 'series' | 'category';
+}
+interface PathStepAdvancedEvent extends ArticleEventBase<'path_step_advanced'> {
+    pathKey: string;
+    fromSlug: string;
+    toSlug: string;
+    direction: 'previous' | 'next';
+}
+type ArticleEvent = ArticleViewedEvent | MeaningfulReadEvent | AuthorClickedEvent | CtaViewedEvent | CtaClickedEvent | SharedEvent | RelatedArticleClickedEvent | PathStepAdvancedEvent;
+/** Register this on `ArticlesConfig.onEvent` to receive every emitted event and translate it to your own analytics stack. */
+type ArticleEventHandler = (event: ArticleEvent) => void;
+type DistributiveOmitTimestamp<T> = T extends ArticleEvent ? Omit<T, 'timestamp'> : never;
+/**
+ * Safely invokes `handler` with `event`, stamping `timestamp`. Swallows any
+ * error thrown by the consuming app's handler - a broken analytics
+ * integration must never break article rendering.
+ */
+declare function emitArticleEvent(handler: ArticleEventHandler | undefined, event: DistributiveOmitTimestamp<ArticleEvent>): void;
+
 /** Keys for each renderable section of the articles listing page. */
 type ArticlesSection = 'hero' | 'search' | 'featured' | 'latest' | 'categories' | 'newsletter';
 /**
@@ -137,6 +291,18 @@ interface HeroConfig {
 }
 /** Controls how article body links set target/rel attributes. */
 type LinkTargetStrategy = 'external-new-tab' | 'all-new-tab' | 'same-tab';
+/**
+ * Controls how listing pages (the articles index, category pages, author
+ * pages) surface articles beyond the first `pageSize`.
+ * - `'load-more'` (default): client-only "Load more" button, no URL change.
+ *   Byte-for-byte identical to pre-27D behavior.
+ * - `'pages'`: real, directly-navigable paginated routes (`/articles/page/2`,
+ *   `/articles/category/[category]/page/2`, `/articles/authors/[author]/page/2`)
+ *   with SSR content, prev/next links, and per-page canonical metadata. The
+ *   route *files* live in the consuming app - see the pagination primitives
+ *   exported from `./server` and the `PaginationNav` component.
+ */
+type ListingPagination = 'load-more' | 'pages';
 /** React components that article MDX bodies can reference by JSX tag name. */
 type MdxComponents = Record<string, ComponentType<never>>;
 type ArticleBreadcrumbToken = 'home' | 'articles' | 'primaryCategory' | 'folderPath' | 'articleTitle';
@@ -219,6 +385,28 @@ interface ArticlesConfig {
     linkTargetStrategy?: LinkTargetStrategy;
     /** Extra components exposed to article MDX bodies by JSX tag name. */
     mdxComponents?: MdxComponents;
+    /**
+     * Chooses how listing pages surface articles beyond the first `pageSize`.
+     * Default: `'load-more'` (unchanged pre-27D behavior). Set to `'pages'` to
+     * opt into real, crawlable paginated routes instead.
+     */
+    listingPagination?: ListingPagination;
+    /**
+     * "Start here" curated reader journeys, keyed by an app-chosen path key.
+     * Distinct from the label-only `series` field/`seriesSlug` pair - a path
+     * can cross series and categories. Every `PathDefinition.articles` slug
+     * must exist and not be `draft: true`; validate with `validateArticles`
+     * before publishing, since a broken reference produces a dead journey
+     * step rather than a build-time failure otherwise.
+     */
+    paths?: Record<string, PathDefinition>;
+    /**
+     * Vendor-neutral event callback (Phase 27F). Fired by components/hooks at
+     * meaningful reader-journey moments (see `ArticleEvent` in `events.ts`).
+     * No PII in any payload. The package never talks to an analytics/email
+     * vendor directly - translate events to PostHog/etc. in this callback.
+     */
+    onEvent?: ArticleEventHandler;
 }
 declare function getBreadcrumbsConfig(config: ArticlesConfig): BreadcrumbsConfig;
 
@@ -242,7 +430,45 @@ declare function searchArticles(query: string, config?: ArticlesConfig): Promise
 declare function categoryToSlug(category: string): string;
 declare function getAllCategories(): Promise<CategoryInfo[]>;
 declare function getArticlesByCategory(categorySlug: string, config?: ArticlesConfig): Promise<Article[]>;
+declare function getRelatedArticlesByCategory(currentSlug: string, category: string, limit?: number, config?: ArticlesConfig): Promise<Article[]>;
 declare function getArticlesByAuthor(authorSlug: string, config: ArticlesConfig): Promise<Article[]>;
+declare function getArticlesBySeries(seriesSlug: string, config?: ArticlesConfig): Promise<Article[]>;
+/**
+ * Series-aware sibling of `getAdjacentArticles`: walks `seriesOrder` within
+ * one series instead of global date order. `previous`/`next` follow series
+ * order (ascending), not chronology.
+ */
+declare function getAdjacentArticlesInSeries(currentSlug: string, seriesSlug: string, config?: ArticlesConfig): Promise<{
+    previous: Article | null;
+    next: Article | null;
+}>;
+/** Looks up one configured `PathDefinition` by its app-chosen key. */
+declare function getPath(pathKey: string, config: ArticlesConfig): PathDefinition | null;
+/** Resolves a path's ordered slugs against the real article set, dropping any that don't resolve (e.g. a draft filtered out of `getAllArticles` in production) rather than throwing - use `validateArticles` to catch broken references before publishing. */
+declare function getPathArticles(pathKey: string, config: ArticlesConfig): Promise<Article[]>;
+type RelatedContentSource = 'path' | 'series' | 'category';
+interface RelatedContentResult {
+    source: RelatedContentSource;
+    /** Heading for a related-content UI - the path's `name`, the article's `series` label, or "More in {category}". */
+    heading: string;
+    articles: Article[];
+    /** Set only when `source === 'path'`. */
+    pathKey?: string;
+    /** Set only when `source === 'path'` - the path's one configured next action. */
+    nextAction?: {
+        label: string;
+        href: string;
+    };
+}
+/**
+ * Reusable related-content selection (Phase 27F): prefers a configured
+ * `Path` containing this article first, then the article's `seriesSlug`,
+ * falling back to 27B's `getRelatedArticlesByCategory` (imported, not
+ * reimplemented) when neither a path nor a series applies - the plain
+ * chronological-within-category behavior stays the fallback, not a full
+ * replacement.
+ */
+declare function getRelatedContent(article: Article, config: ArticlesConfig, limit?: number): Promise<RelatedContentResult>;
 
 declare function generateRssFeed(articles: Article[], config: ArticlesConfig): string;
 declare function generateArticleStaticParams(): {
@@ -254,17 +480,87 @@ declare function generateCategoryStaticParams(): Promise<{
 declare function generateAuthorStaticParams(config: ArticlesConfig): {
     author: string;
 }[];
+/** Static params for `/articles/series/[series]` - one entry per distinct `seriesSlug` found across all articles. */
+declare function generateSeriesStaticParams(config?: ArticlesConfig): Promise<{
+    series: string;
+}[]>;
+declare function resolveSearchMetadata(article: Pick<Article, 'title' | 'excerpt' | 'searchTitle' | 'searchDescription'>, config: Pick<ArticlesConfig, 'siteName'>): {
+    title: string;
+    description: string;
+};
+declare function resolveSocialMetadata(article: Pick<Article, 'title' | 'excerpt' | 'featuredImage' | 'socialTitle' | 'socialDescription' | 'socialImage'>, siteUrl: string): {
+    title: string;
+    description: string;
+    imageUrl: string;
+};
 declare function generateArticleMetadata(slug: string, config: ArticlesConfig): Promise<Metadata>;
 declare function generateArticlesIndexMetadata(config: ArticlesConfig): Metadata;
 declare function generateCategoryMetadata(categorySlug: string, config: ArticlesConfig): Promise<Metadata>;
+/** Metadata for a series landing page, analogous to `generateCategoryMetadata`. Series display name comes from the first matching article's label-only `series` string, falling back to `seriesSlug` itself. */
+declare function generateSeriesMetadata(seriesSlug: string, config: ArticlesConfig): Promise<Metadata>;
 declare function generateAuthorMetadata(authorSlug: string, config: ArticlesConfig): Promise<Metadata>;
+/** Per-page metadata for `/articles/page/[page]` in `listingPagination: 'pages'` mode. Page 1 is identical to `generateArticlesIndexMetadata`. */
+declare function generateArticlesIndexPageMetadata(page: number, totalPages: number, config: ArticlesConfig): Metadata;
+/** Per-page metadata for `/articles/category/[category]/page/[page]` in `listingPagination: 'pages'` mode. */
+declare function generateCategoryPageMetadata(categorySlug: string, page: number, totalPages: number, config: ArticlesConfig): Promise<Metadata>;
+/** Per-page metadata for `/articles/authors/[author]/page/[page]` in `listingPagination: 'pages'` mode. */
+declare function generateAuthorPageMetadata(authorSlug: string, page: number, totalPages: number, config: ArticlesConfig): Promise<Metadata>;
 declare function buildArticleBreadcrumbs(article: Pick<Article, 'slug' | 'title' | 'category'>, config: ArticlesConfig): BreadcrumbItem[];
 declare function buildCategoryBreadcrumbs(category: string, config: ArticlesConfig, categoryName?: string): BreadcrumbItem[];
 declare function buildAuthorBreadcrumbs(author: AuthorProfile, config: ArticlesConfig): BreadcrumbItem[];
 declare function resolveAuthorAvatar(author: AuthorProfile, config: ArticlesConfig): string;
 declare function getArticleSitemapEntries(baseUrlOrConfig: string | ArticlesConfig): Promise<MetadataRoute.Sitemap>;
 
+interface PaginatedArticles {
+    /** Articles belonging to this page only (already sliced). */
+    articles: Article[];
+    /** Clamped to the range `[1, totalPages]`. */
+    page: number;
+    totalPages: number;
+    hasPrevious: boolean;
+    hasNext: boolean;
+}
+/** Context threaded from a listing page component down into `LatestArticles`/`PaginationNav` in `'pages'` mode. */
+interface ListingPaginationContext {
+    page: number;
+    totalPages: number;
+    /** Un-paginated route path for this listing, e.g. `/articles` or `/articles/category/campaigns`. */
+    basePath: string;
+}
+interface PaginationLinks {
+    /** This page's own canonical URL - never points back to page 1 for page > 1. */
+    canonicalUrl: string;
+    prevUrl: string | null;
+    nextUrl: string | null;
+}
+declare function getTotalPages(totalCount: number, pageSize: number): number;
+/** Slices `articles` to the requested page, clamping out-of-range page numbers into `[1, totalPages]`. */
+declare function paginateArticles(articles: Article[], page: number, pageSize: number): PaginatedArticles;
+/** Page 1 is the un-suffixed `basePath` itself; page N>1 is `${basePath}/page/${N}`. */
+declare function buildPageUrl(basePath: string, page: number): string;
+declare function buildPaginationLinks(basePath: string, page: number, totalPages: number): PaginationLinks;
+/**
+ * Static params for pages 2..totalPages (page 1 has no `/page/1` route - it's
+ * served by the un-paginated base route). For nested dynamic segments (e.g.
+ * `/articles/category/[category]/page/[page]`), combine this per-category in
+ * the consuming app's `generateStaticParams` - see README.
+ */
+declare function generateListingPageStaticParams(totalPages: number): {
+    page: string;
+}[];
+declare function parsePageParam(raw: string | undefined | null): number;
+declare function isPageOutOfRange(page: number, totalPages: number): boolean;
+
 declare function markdownToHtml(markdown: string, articleSlug?: string, config?: ArticlesConfig): Promise<string>;
+interface ContentSlotBoundaries {
+    /** Character offset (into the raw markdown source) right after the first paragraph - the "intro" boundary. */
+    introEnd: number;
+    /** Character offset right after the middle paragraph - the "mid content" boundary. */
+    mid: number;
+    /** Total top-level paragraph count found. */
+    paragraphCount: number;
+}
+declare function getContentSlotBoundaries(markdown: string): ContentSlotBoundaries | null;
 declare function extractToc(markdown: string): Promise<TocItem[]>;
 
 type ArticlesErrorCode = 'article-directory-read-failed' | 'article-load-failed' | 'article-markdown-load-failed' | 'markdown-conversion-failed' | 'unsafe-image-path';
@@ -278,12 +574,37 @@ type ArticlesErrorReport = Readonly<{
 type ArticlesErrorHandler = (report: ArticlesErrorReport) => void;
 declare function setArticlesErrorHandler(handler?: ArticlesErrorHandler): void;
 
+/**
+ * Sanitized, non-PII context passed into `ArticleContent`'s slot render
+ * props - deliberately a narrow subset of `Article`, not the whole object
+ * (no raw `content`/`mdxSource`, no author email or anything author-PII).
+ */
+interface ArticleSlotContext {
+    slug: string;
+    title: string;
+    category: string;
+    tags: string[];
+    readTime: string;
+    wordCount?: number;
+    authorSlug?: string;
+    seriesSlug?: string;
+    primaryActionId?: string;
+}
+type ArticleSlotContent = ReactNode | ((context: ArticleSlotContext) => ReactNode);
 type ArticleContentProps = Readonly<{
     article: Article;
     className?: string;
     config?: ArticlesConfig;
+    /** Rendered immediately before the article body - the "around the body, not inside it" counterpart to `config.mdxComponents` (which places content *inside* MDX bodies). */
+    afterHero?: ArticleSlotContent;
+    /** Rendered right after the first paragraph, resolved deterministically from the parsed AST (see `getContentSlotBoundaries`). Falls back to not rendering (never a brittle string split) when the source has no detectable paragraphs, e.g. MDX using JSX-heavy syntax remark-parse can't read as plain markdown. */
+    afterIntro?: ArticleSlotContent;
+    /** Rendered after roughly the middle paragraph. Same fallback behavior as `afterIntro`. */
+    midContent?: ArticleSlotContent;
+    /** Rendered immediately after the article body. */
+    afterContent?: ArticleSlotContent;
 }>;
-declare function ArticleContent({ article, className, config }: ArticleContentProps): Promise<react_jsx_runtime.JSX.Element>;
+declare function ArticleContent({ article, className, config, afterHero, afterIntro, midContent, afterContent, }: ArticleContentProps): Promise<react_jsx_runtime.JSX.Element>;
 
 type ArticleTOCProps = Readonly<{
     toc: TocItem[];
@@ -291,4 +612,29 @@ type ArticleTOCProps = Readonly<{
 }>;
 declare function ArticleTOC({ toc, className }: ArticleTOCProps): react_jsx_runtime.JSX.Element | null;
 
-export { type Article, ArticleContent, ArticleTOC, type ArticlesConfig, type ArticlesErrorCode, type ArticlesErrorContext, type ArticlesErrorHandler, type ArticlesErrorReport, type AuthorProfile, type AuthorSocial, type BreadcrumbItem, type CategoryInfo, type LinkTargetStrategy, type TocItem, buildArticleBreadcrumbs, buildAuthorBreadcrumbs, buildCategoryBreadcrumbs, categoryToSlug, extractToc, generateArticleMetadata, generateArticleStaticParams, generateArticlesIndexMetadata, generateAuthorMetadata, generateAuthorStaticParams, generateCategoryMetadata, generateCategoryStaticParams, generateRssFeed, getAdjacentArticles, getAiRobotsTxtRules, getAllArticles, getAllAuthors, getAllCategories, getArticleAiHeaders, getArticleAuthors, getArticleMarkdown, getArticleMarkdownResponse, getArticleMarkdownUrl, getArticleMetadata, getArticleSitemapEntries, getArticlesByAuthor, getArticlesByCategory, getAuthorBySlug, getAvailableArticleSlugs, getBreadcrumbsConfig, markdownToHtml, resolveAuthorAvatar, sanitizeImagePath, searchArticles, setArticlesErrorHandler };
+type ValidationSeverity = 'error' | 'warning';
+interface ValidationIssue {
+    severity: ValidationSeverity;
+    /** Stable machine-readable code, e.g. `'duplicate-canonical-url'`. */
+    code: string;
+    message: string;
+    articleSlug?: string;
+    pathKey?: string;
+}
+interface ValidationResult {
+    ok: boolean;
+    errors: ValidationIssue[];
+    warnings: ValidationIssue[];
+}
+/**
+ * Validates a loaded article set + config. Warnings cover optional
+ * discovery-field issues (missing excerpt/date, over-length search/social
+ * fields, category slug collisions); errors cover broken reader journeys
+ * (duplicate canonical URLs, unknown author references, series order
+ * collisions, missing/draft path references, unsafe URL schemes).
+ */
+declare function validateArticles(articles: Article[], config: ArticlesConfig): ValidationResult;
+/** Convenience wrapper: loads every article via `getAllArticles(config)` (fs-dependent) then validates. Suitable for a consuming app's own `scripts/validate-articles.ts` invoked in CI before publish. */
+declare function validateAllArticles(config: ArticlesConfig): Promise<ValidationResult>;
+
+export { type Article, ArticleContent, type ArticleEvent, type ArticleEventHandler, type ArticleEventName, type ArticleSlotContent, type ArticleSlotContext, ArticleTOC, type ArticleViewedEvent, type ArticlesConfig, type ArticlesErrorCode, type ArticlesErrorContext, type ArticlesErrorHandler, type ArticlesErrorReport, type AuthorClickedEvent, type AuthorProfile, type AuthorSocial, type BreadcrumbItem, type CategoryInfo, type ContentSlotBoundaries, type CtaClickedEvent, type CtaViewedEvent, type LinkTargetStrategy, type ListingPagination, type ListingPaginationContext, type MeaningfulReadEvent, type PaginatedArticles, type PaginationLinks, type PathDefinition, type PathStepAdvancedEvent, type RelatedArticleClickedEvent, type RelatedContentResult, type RelatedContentSource, type SharedEvent, type TocItem, type ValidationIssue, type ValidationResult, type ValidationSeverity, buildArticleBreadcrumbs, buildAuthorBreadcrumbs, buildCategoryBreadcrumbs, buildPageUrl, buildPaginationLinks, categoryToSlug, emitArticleEvent, extractToc, generateArticleMetadata, generateArticleStaticParams, generateArticlesIndexMetadata, generateArticlesIndexPageMetadata, generateAuthorMetadata, generateAuthorPageMetadata, generateAuthorStaticParams, generateCategoryMetadata, generateCategoryPageMetadata, generateCategoryStaticParams, generateListingPageStaticParams, generateRssFeed, generateSeriesMetadata, generateSeriesStaticParams, getAdjacentArticles, getAdjacentArticlesInSeries, getAiRobotsTxtRules, getAllArticles, getAllAuthors, getAllCategories, getArticleAiHeaders, getArticleAuthors, getArticleMarkdown, getArticleMarkdownResponse, getArticleMarkdownUrl, getArticleMetadata, getArticleSitemapEntries, getArticlesByAuthor, getArticlesByCategory, getArticlesBySeries, getAuthorBySlug, getAvailableArticleSlugs, getBreadcrumbsConfig, getContentSlotBoundaries, getPath, getPathArticles, getRelatedArticlesByCategory, getRelatedContent, getTotalPages, isPageOutOfRange, markdownToHtml, paginateArticles, parsePageParam, resolveAuthorAvatar, resolveSearchMetadata, resolveSocialMetadata, sanitizeImagePath, searchArticles, setArticlesErrorHandler, validateAllArticles, validateArticles };