@rimelight/cms 0.0.3 → 0.0.5

package/dist/index.d.mts

@@ -0,0 +1,724 @@
+import { $ as StepItemBlock, A as ComponentShowcaseBlockProps, B as LivePreviewBlockProps, C as CardBlock, D as CodeBlock, E as CardsBlockProps, F as FileTreeNode, G as ParagraphBlockProps, H as MAX_SECTION_HEADING_LEVEL, I as HeadingLevel, J as ScriptBlock, K as SceneBlock, L as ImageBlock, M as DialogueBlockProps, N as FileTreeBlock, O as CodeBlockProps, P as FileTreeBlockProps, Q as Setting, R as ImageBlockProps, S as CalloutVariant, T as CardsBlock, U as MIN_SECTION_HEADING_LEVEL, V as MAX_SECTION_DEPTH, W as ParagraphBlock, X as SectionBlock, Y as ScriptBlockProps, Z as SectionBlockProps, _ as ApiDocumentationBlockProps, _t as InlineNode, a as PageVersionComment, at as TableBlock, b as CalloutBlock, bt as PageMentionNode, c as TemplateApprovalRules, ct as TabsBlock, d as PageContent, dt as Transition, et as StepItemBlockProps, f as PageMetadata, ft as TypedBlock, g as ApiDocumentationBlock, gt as MediaValue, h as ALLOWED_CHILDREN_MAP, ht as calculateHeadingLevel, i as PageVersionApproval, it as TabItemBlockProps, j as DialogueBlock, k as ComponentShowcaseBlock, l as TemplateRolePermissions, lt as TabsBlockProps, m as RegisterPageTypes, mt as TypedScriptBlockProps, n as BylineRole, nt as StepsBlockProps, o as PageVersionStatus, ot as TableBlockProps, p as PageType, pt as TypedSceneBlockProps, q as SceneBlockProps, r as PageVersion, rt as TabItemBlock, s as PageTemplate, st as TableColumnDef, t as BylineCredit, tt as StepsBlock, u as Localized, ut as TimeOfDay, v as BaseBlock, vt as InlineNodeType, w as CardBlockProps, x as CalloutBlockProps, xt as TextInlineNode, y as BlockType, yt as LinkInlineNode, z as LivePreviewBlock } from "./bylines-Csggkl-g.mjs";
+import { Byline, InsertSiteSettings, NewByline, SiteSettings, SiteSettingsBranding, SiteSettingsSeo, bylines, contentSearchIndex, pageDraftLocks, pageDrafts, pageTaxonomyTerms, pageTemplates, pageVersionApprovals, pageVersionComments, pageVersions, pages, siteSettings, taxonomyTerms } from "./schema/index.mjs";
+import { R2StorageOptions, StorageConfig, StorageFile, StorageListOptions, StorageListResult, StorageUploadOptions, deleteR2File, getR2Bucket, listR2Files, r2, uploadR2File } from "./storage/index.mjs";
+import { RimelightCmsOptions, rimelightCms } from "./integration.mjs";
+import { AuthAdapter, AuthAdapter as CmsAuthAdapter, UserSessionContext, UserType, auth0Auth, cfAccessAuth, evaluateAccess, hasPermission, hasRole, mockAuth } from "@rimelight/auth";
+import { SQL } from "drizzle-orm";
+import { Toast, ToastInput, ToastItem, addToast, clearToasts, removeToast, showErrorToast, showSuccessToast, toast, toasts } from "@rimelight/ui/components/toast/store.ts";
+import { SidebarItem, SidebarScope } from "@rimelight/ui/components/sidebar/sidebar.ts";
+import { BadgeProps } from "@rimelight/ui/components/badge/badge.ts";
+//#region src/core/page-definitions.d.ts
+type FieldType = "text" | "number" | "enum" | "text-array" | "page" | "page-array";
+interface FieldDefinition {
+  type: FieldType;
+  label: {
+    en: string;
+  };
+  defaultValue: any;
+  options?: {
+    en: string;
+  }[];
+  allowedPageTypes?: string[];
+}
+interface PropertyGroup {
+  label: {
+    en: string;
+  };
+  defaultOpen: boolean;
+  fields: Record<string, FieldDefinition>;
+}
+interface PageDefinition {
+  typeLabelKey: string;
+  properties: Record<string, PropertyGroup>;
+  /**
+   * Factory that returns the initial blocks seeded when a page of this type is created
+   */
+  initialBlocks?: () => BaseBlock[];
+}
+declare function definePageDefinition(def: PageDefinition): PageDefinition;
+declare const DOCUMENT_DEFINITION: PageDefinition;
+declare const BLOG_POST_DEFINITION: PageDefinition;
+declare const PATCH_NOTE_DEFINITION: PageDefinition;
+declare const LOCATION_DEFINITION: PageDefinition;
+declare const SPECIES_DEFINITION: PageDefinition;
+declare const CHARACTER_DEFINITION: PageDefinition;
+declare const SKILL_DEFINITION: PageDefinition;
+declare const ITEM_DEFINITION: PageDefinition;
+declare const OBJECT_DEFINITION: PageDefinition;
+declare const GROUP_DEFINITION: PageDefinition;
+declare const HERO_DEFINITION: PageDefinition;
+declare const CARD_DEFINITION: PageDefinition;
+declare const SERIES_DEFINITION: PageDefinition;
+declare const PAGE_MAP: Record<string, PageDefinition>;
+declare function getPageDefinition(type: string): PageDefinition;
+//#endregion
+//#region src/markdown/serializer.d.ts
+declare function inlinesToMarkdown(inlines: InlineNode[] | {
+  en?: string;
+} | string | undefined): string;
+declare function blocksToMarkdown(blocks?: BaseBlock[], options?: {
+  sectionLevel?: number;
+}): string;
+//#endregion
+//#region src/core/registry.d.ts
+interface BlockDefinition {
+  type: string;
+  label: string;
+  description?: string;
+  defaultProps: Record<string, any>;
+  allowChildren?: boolean;
+}
+declare const BlockRegistry: {
+  register(def: BlockDefinition): void;
+  get(type: string): BlockDefinition | undefined;
+  getAll(): BlockDefinition[];
+};
+//#endregion
+//#region src/core/validator.d.ts
+declare function isValidUUID(uuid: string): boolean;
+declare function validateBlockAST(blocks: BaseBlock[]): {
+  valid: boolean;
+  errors: string[];
+};
+//#endregion
+//#region src/auth/permissions.d.ts
+declare const cmsStatements: {
+  readonly page: readonly ["create", "read", "update", "delete", "publish", "approve"];
+  readonly template: readonly ["create", "read", "update", "delete", "instantiate"];
+  readonly draft: readonly ["checkout", "edit", "release", "force_unlock"];
+  readonly version: readonly ["create", "review", "approve", "publish"];
+};
+declare const cmsAc: {
+  readonly page: {
+    readonly read: readonly ["admin", "editor"];
+    readonly update: readonly ["admin", "editor"];
+    readonly delete: readonly ["admin"];
+    readonly publish: readonly ["admin"];
+    readonly approve: readonly ["admin"];
+  };
+  readonly template: {
+    readonly read: readonly ["admin", "editor"];
+    readonly update: readonly ["admin"];
+    readonly delete: readonly ["admin"];
+    readonly instantiate: readonly ["admin", "editor"];
+  };
+  readonly draft: {
+    readonly checkout: readonly ["admin", "editor"];
+    readonly edit: readonly ["admin", "editor"];
+    readonly release: readonly ["admin", "editor"];
+    readonly force_unlock: readonly ["admin"];
+  };
+  readonly version: {
+    readonly create: readonly ["admin", "editor"];
+    readonly review: readonly ["admin", "editor"];
+    readonly approve: readonly ["admin"];
+    readonly publish: readonly ["admin"];
+  };
+};
+interface UserSessionContext$1 {
+  userId: string;
+  roles: string[];
+  permissions: string[];
+}
+//#endregion
+//#region src/auth/filter-blocks.d.ts
+/**
+ * Pure immutable function for Astro SSR Reader. Returns new array; never mutates input AST
+ */
+declare function filterBlocksForReader(blocks: BaseBlock[], session?: UserSessionContext$1): BaseBlock[];
+//#endregion
+//#region src/auth/editor-guards.d.ts
+/**
+ * Checks if a user has edit rights over a specific block
+ */
+declare function canUserEditBlock(block: BaseBlock, session?: UserSessionContext$1): boolean;
+/**
+ * Recursively checks if a block or ANY of its descendants are locked or un-editable
+ */
+declare function hasLockedDescendants(block: BaseBlock, session?: UserSessionContext$1): boolean;
+/**
+ * Server-Side Guard: Validates that an incoming edited block tree obeys templated & authorization
+ * invariants
+ */
+declare function validateServerBlockPayload(existingTree: BaseBlock[], incomingTree: BaseBlock[], session?: UserSessionContext$1): {
+  valid: boolean;
+  reason?: string;
+};
+//#endregion
+//#region src/auth/filter-templates.d.ts
+declare function canUserCreateFromTemplate(template: PageTemplate, session?: UserSessionContext$1): boolean;
+declare function canUserEditFromTemplate(template: PageTemplate, session?: UserSessionContext$1): boolean;
+declare function canUserReviewFromTemplate(template: PageTemplate, session?: UserSessionContext$1): boolean;
+declare function canUserViewFromTemplate(template: PageTemplate, session?: UserSessionContext$1): boolean;
+declare function canUserInstantiateTemplate(template: PageTemplate, session?: UserSessionContext$1): boolean;
+declare function filterTemplatesForUser(templates: PageTemplate[], session?: UserSessionContext$1): PageTemplate[];
+//#endregion
+//#region src/cache/purge.d.ts
+interface CachePurgeOptions {
+  slug: string;
+  locales: string[];
+  domain?: string;
+  basePath?: string;
+  isEnterpriseCloudflare?: boolean;
+}
+declare function invalidatePageCache(options: CachePurgeOptions): Promise<boolean>;
+//#endregion
+//#region src/search/query.d.ts
+declare const POSTGRES_SEARCH_CONFIGS: Record<string, string>;
+declare function getPostgresSearchConfig(locale: string): string;
+//#endregion
+//#region src/core/excerpt.d.ts
+/**
+ * Recursively extracts plain text from an array of CMS blocks.
+ */
+declare function extractTextFromBlocks(blocks: BaseBlock[] | undefined | null, locale?: string): string;
+interface ExcerptOptions {
+  maxLength?: number;
+  locale?: string;
+  fallback?: string;
+}
+/**
+ * Generates an SEO / RSS safe plain text excerpt from a CMS page or block payload.
+ */
+declare function createPageExcerpt(page: {
+  description?: unknown;
+  content?: unknown;
+  title?: unknown;
+} | null | undefined, options?: ExcerptOptions): string;
+//#endregion
+//#region src/services/site-settings.d.ts
+declare const DEFAULT_SITE_SETTINGS: InsertSiteSettings;
+/**
+ * Retrieves the dynamic site settings from the database. If no settings are found, seeds the
+ * default record and returns it.
+ */
+declare function getSiteSettings(db: any, fallbackDefaults?: Partial<InsertSiteSettings>): Promise<SiteSettings>;
+/**
+ * Updates dynamic site settings in the database.
+ */
+declare function updateSiteSettings(db: any, updates: Partial<InsertSiteSettings>, id?: string): Promise<SiteSettings>;
+//#endregion
+//#region src/loader/live.d.ts
+interface CmsLoaderOptions {
+  type?: PageType | undefined;
+  db?: any;
+  locale?: string | undefined;
+  includeDrafts?: boolean | undefined;
+  includeScheduled?: boolean | undefined;
+  taxonomy?: {
+    category?: string | undefined;
+    tag?: string | undefined;
+    [key: string]: string | undefined;
+  } | undefined;
+}
+interface CmsPageData {
+  id: string;
+  slug: string;
+  type: PageType;
+  title: Localized;
+  resolvedTitle: string;
+  description?: Localized;
+  resolvedDescription: string;
+  excerpt: string;
+  tags: Localized[];
+  authorIds: string[];
+  blocks: BaseBlock[];
+  properties: Record<string, any>;
+  publishedVersionId: string | null;
+  postedAt: Date | null;
+  createdAt: Date;
+  updatedAt: Date | null;
+}
+interface CmsEntry {
+  id: string;
+  data: CmsPageData;
+}
+interface CacheHint {
+  tags?: string[];
+  lastModified?: Date;
+  maxAge?: number;
+}
+/**
+ * Direct querying helper for CMS collections.
+ */
+declare function getCmsCollection(db: any, options?: CmsLoaderOptions & {
+  limit?: number | undefined;
+  offset?: number | undefined;
+  where?: SQL | undefined;
+}): Promise<{
+  entries: CmsEntry[];
+  cacheHint: CacheHint;
+}>;
+/**
+ * Direct querying helper for a single CMS entry by slug or id.
+ */
+declare function getCmsEntry(db: any, slugOrId: string, options?: CmsLoaderOptions): Promise<{
+  entry: CmsEntry | null;
+  cacheHint: CacheHint;
+}>;
+/**
+ * Astro Live Loader for CMS collections. Use inside src/live.config.ts with defineLiveCollection({
+ * loader: rimelightCmsLoader({ type: 'blog' }) })
+ */
+declare function rimelightCmsLoader(loaderOptions?: CmsLoaderOptions): {
+  name: string;
+  loadCollection: (context: {
+    filter?: {
+      limit?: number;
+      offset?: number;
+    };
+    collection?: string;
+  }) => Promise<{
+    entries: CmsEntry[];
+    cacheHint: CacheHint;
+  }>;
+  loadEntry: (context: {
+    filter: {
+      id: string;
+    };
+    collection?: string;
+  }) => Promise<{
+    id: string;
+    data: CmsPageData;
+    cacheHint: CacheHint;
+  } | undefined>;
+};
+//#endregion
+//#region src/cron/scheduled.d.ts
+interface CmsCronResult {
+  expiredLocksCleaned: number;
+  scheduledPagesActive: number;
+  timestamp: string;
+}
+/**
+ * Handles the periodic Cloudflare Worker cron trigger (e.g. "* * * * *").
+ *
+ * - Cleans up expired page draft locks
+ * - Checks for active scheduled pages
+ */
+declare function handleCmsCron(_event: any, _env: any, _ctx: any, db: any): Promise<CmsCronResult>;
+//#endregion
+//#region src/mcp/index.d.ts
+declare const CMS_MCP_TOOLS: ({
+  name: string;
+  description: string;
+  inputSchema: {
+    type: string;
+    properties: {
+      type: {
+        type: string;
+        description: string;
+      };
+      includeDrafts: {
+        type: string;
+        description: string;
+      };
+      limit: {
+        type: string;
+        description: string;
+      };
+      slugOrId?: never;
+      pageId?: never;
+      userId?: never;
+      blocks?: never;
+      properties?: never;
+      name?: never;
+      description?: never;
+      author?: never;
+      email?: never;
+      branding?: never;
+      seo?: never;
+    };
+    required?: never;
+  };
+} | {
+  name: string;
+  description: string;
+  inputSchema: {
+    type: string;
+    properties: {
+      slugOrId: {
+        type: string;
+        description: string;
+      };
+      type?: never;
+      includeDrafts?: never;
+      limit?: never;
+      pageId?: never;
+      userId?: never;
+      blocks?: never;
+      properties?: never;
+      name?: never;
+      description?: never;
+      author?: never;
+      email?: never;
+      branding?: never;
+      seo?: never;
+    };
+    required: string[];
+  };
+} | {
+  name: string;
+  description: string;
+  inputSchema: {
+    type: string;
+    properties: {
+      pageId: {
+        type: string;
+        description: string;
+      };
+      userId: {
+        type: string;
+        description: string;
+      };
+      blocks: {
+        type: string;
+        description: string;
+      };
+      properties: {
+        type: string;
+        description: string;
+      };
+      type?: never;
+      includeDrafts?: never;
+      limit?: never;
+      slugOrId?: never;
+      name?: never;
+      description?: never;
+      author?: never;
+      email?: never;
+      branding?: never;
+      seo?: never;
+    };
+    required: string[];
+  };
+} | {
+  name: string;
+  description: string;
+  inputSchema: {
+    type: string;
+    properties: {
+      type?: never;
+      includeDrafts?: never;
+      limit?: never;
+      slugOrId?: never;
+      pageId?: never;
+      userId?: never;
+      blocks?: never;
+      properties?: never;
+      name?: never;
+      description?: never;
+      author?: never;
+      email?: never;
+      branding?: never;
+      seo?: never;
+    };
+    required?: never;
+  };
+} | {
+  name: string;
+  description: string;
+  inputSchema: {
+    type: string;
+    properties: {
+      name: {
+        type: string;
+      };
+      description: {
+        type: string;
+      };
+      author: {
+        type: string;
+      };
+      email: {
+        type: string;
+      };
+      branding: {
+        type: string;
+      };
+      seo: {
+        type: string;
+      };
+      type?: never;
+      includeDrafts?: never;
+      limit?: never;
+      slugOrId?: never;
+      pageId?: never;
+      userId?: never;
+      blocks?: never;
+      properties?: never;
+    };
+    required?: never;
+  };
+})[];
+/**
+ * Handles Model Context Protocol (MCP) JSON-RPC requests for CMS tools.
+ */
+declare function handleCmsMcpRequest(body: {
+  jsonrpc?: string;
+  id?: string | number;
+  method: string;
+  params?: any;
+}, db: any): Promise<any>;
+//#endregion
+//#region src/services/bylines.d.ts
+/**
+ * Returns all active (non-deleted) bylines.
+ */
+declare function getBylines(db: any): Promise<Byline[]>;
+/**
+ * Retrieves a single byline by ID or slug.
+ */
+declare function getByline(db: any, idOrSlug: string): Promise<Byline | null>;
+/**
+ * Creates a new byline.
+ */
+declare function createByline(db: any, data: NewByline): Promise<Byline>;
+/**
+ * Updates an existing byline.
+ */
+declare function updateByline(db: any, id: string, data: Partial<NewByline>): Promise<Byline | null>;
+/**
+ * Soft deletes a byline.
+ */
+declare function deleteByline(db: any, id: string): Promise<boolean>;
+//#endregion
+//#region src/core/preview.d.ts
+/**
+ * Generates and verifies HMAC-signed stateless preview tokens for draft pages.
+ */
+/**
+ * Generates a signed token for a page ID valid for ttlSeconds (default 24h).
+ */
+declare function generatePreviewToken(pageId: string, secret: string, ttlSeconds?: number): Promise<{
+  token: string;
+  expiresAt: number;
+}>;
+/**
+ * Verifies a signed preview token against a pageId and secret.
+ */
+declare function verifyPreviewToken(pageId: string, token: string, secret: string): Promise<boolean>;
+//#endregion
+//#region src/core/diff.d.ts
+type DiffChangeType = "added" | "removed" | "modified" | "unchanged";
+interface BlockDiff {
+  blockId: string;
+  type: string;
+  status: DiffChangeType;
+  oldBlock?: BaseBlock;
+  newBlock?: BaseBlock;
+  fieldChanges?: {
+    field: string;
+    oldValue: any;
+    newValue: any;
+  }[];
+}
+interface PageVersionDiff {
+  blocks: BlockDiff[];
+  metaChanges: {
+    field: string;
+    oldValue: any;
+    newValue: any;
+  }[];
+  summary: {
+    addedCount: number;
+    removedCount: number;
+    modifiedCount: number;
+    unchangedCount: number;
+  };
+}
+/**
+ * Calculates a detailed diff between an old list of blocks and a new list of blocks.
+ */
+declare function diffBlocks(oldBlocks?: BaseBlock[], newBlocks?: BaseBlock[]): BlockDiff[];
+/**
+ * Compares two page snapshots (metadata + content blocks).
+ */
+declare function diffPageSnapshots(oldSnapshot: any, newSnapshot: any): PageVersionDiff;
+//#endregion
+//#region src/services/search-indexer.d.ts
+declare function indexPageForSearch(db: any, page: {
+  id: string;
+  title: any;
+  content: any;
+}, locales?: string[]): Promise<void>;
+//#endregion
+//#region src/core/types/taxonomies.d.ts
+interface TaxonomyTerm {
+  id: string;
+  taxonomy: string;
+  slug: string;
+  label: Localized | string;
+  description?: Localized | string | null;
+  parentId?: string | null;
+  displayOrder?: number;
+  children?: TaxonomyTerm[];
+  count?: number;
+  createdAt?: Date;
+  updatedAt?: Date;
+}
+interface TaxonomyQueryOptions {
+  includeCounts?: boolean;
+  locale?: string;
+}
+//#endregion
+//#region src/services/taxonomies.d.ts
+/**
+ * Retrieves all terms for a given taxonomy. If hierarchical, returns a tree structure with
+ * `children: TaxonomyTerm[]`.
+ */
+declare function getTaxonomyTerms(db: any, taxonomy: string, options?: TaxonomyQueryOptions): Promise<TaxonomyTerm[]>;
+/**
+ * Retrieves a single term by taxonomy and slug.
+ */
+declare function getTerm(db: any, taxonomy: string, slug: string): Promise<TaxonomyTerm | null>;
+/**
+ * Retrieves all terms assigned to a specific page entry.
+ */
+declare function getEntryTerms(db: any, pageId: string, taxonomy?: string): Promise<TaxonomyTerm[]>;
+/**
+ * Retrieves pages tagged with a given taxonomy term.
+ */
+declare function getEntriesByTerm(db: any, taxonomy: string, slug: string, options?: {
+  limit?: number;
+  offset?: number;
+  type?: string;
+}): Promise<{
+  entries: never[];
+  total: number;
+  term?: never;
+} | {
+  entries: any;
+  total: any;
+  term: TaxonomyTerm;
+}>;
+/**
+ * Sets/syncs the assigned terms for a page within a specific taxonomy.
+ */
+declare function assignEntryTerms(db: any, pageId: string, taxonomy: string, termIds: string[]): Promise<void>;
+/**
+ * Creates a new taxonomy term.
+ */
+declare function createTerm(db: any, data: {
+  taxonomy: string;
+  slug: string;
+  label: any;
+  description?: any;
+  parentId?: string | null;
+  displayOrder?: number;
+}): Promise<any>;
+/**
+ * Updates an existing taxonomy term.
+ */
+declare function updateTerm(db: any, id: string, updates: Partial<{
+  slug: string;
+  label: any;
+  description: any;
+  parentId: string | null;
+  displayOrder: number;
+}>): Promise<any>;
+/**
+ * Deletes a taxonomy term.
+ */
+declare function deleteTerm(db: any, id: string): Promise<{
+  success: boolean;
+}>;
+//#endregion
+//#region src/docs/config.d.ts
+interface EditLinkConfig {
+  baseUrl: string;
+}
+interface TableOfContentsConfig {
+  minHeadingLevel?: number;
+  maxHeadingLevel?: number;
+}
+interface DocsConfig {
+  basePath?: string;
+  sidebar: (SidebarItem | SidebarScope)[] | {
+    scopes: SidebarScope[];
+  };
+  editLink?: EditLinkConfig;
+  tableOfContents?: false | TableOfContentsConfig;
+}
+declare const defineDocsConfig: <const T extends DocsConfig>(config: T) => T;
+//#endregion
+//#region src/docs/sidebar.d.ts
+interface ResolvedSidebarItem {
+  label: string;
+  href?: string | undefined;
+  icon?: string | undefined;
+  badge?: string | BadgeProps | undefined;
+  active?: boolean | undefined;
+  children?: ResolvedSidebarItem[] | undefined;
+  collapsed?: boolean | undefined;
+}
+interface ResolvedScope {
+  id: string;
+  label: string;
+  href: string;
+  icon?: string | undefined;
+  active?: boolean | undefined;
+}
+declare function getDocsSidebar(config: DocsConfig, locale: string, currentPath: string, activeVersion?: string, includeVersionInUrl?: boolean): Promise<{
+  items: ResolvedSidebarItem[];
+  scopes: ResolvedScope[];
+  activeScope?: ResolvedScope | undefined;
+}>;
+declare function getSurroundItems(sidebar: ResolvedSidebarItem[], currentPath: string): {
+  prev: {
+    label: string;
+    href: string;
+  } | null | undefined;
+  next: {
+    label: string;
+    href: string;
+  } | null | undefined;
+};
+//#endregion
+//#region src/docs/routing.d.ts
+interface DocEntry {
+  id?: string;
+  slug?: string;
+  version?: string;
+  properties?: Record<string, any>;
+  [key: string]: any;
+}
+declare function getDocsVersions(entries: (DocEntry | string)[], locale?: string): string[];
+declare function parseDocsSlug(slug: string | undefined, versions: string[]): {
+  activeVersion: string | undefined;
+  contentPath: string;
+  includeVersionInUrl: boolean;
+};
+declare function formatDocsUrl(href: string, locale: string, activeVersion?: string, includeVersionInUrl?: boolean): string;
+//#endregion
+//#region src/docs/toc.d.ts
+interface TableOfContentsHeading {
+  depth: number;
+  slug: string;
+  text: string;
+}
+declare function slugifyHeading(text: string): string;
+declare function extractHeadingsFromBlocks(blocks?: any[], currentDepth?: number): TableOfContentsHeading[];
+//#endregion
+//#region src/docs/agent.d.ts
+interface AgentMarkdownOptions {
+  siteUrl?: string;
+  llmsUrl?: string;
+  sourceUrl?: string;
+}
+/**
+ * Renders a CMS page record into clean, agent-ready Markdown with YAML frontmatter.
+ */
+declare function renderPageAsMarkdown(page: any, locale?: string, options?: AgentMarkdownOptions): string;
+/**
+ * Collate all published pages of a given type into a single corpus markdown document.
+ */
+declare function renderCorpusMarkdown(db: any, options?: {
+  type?: string;
+  locale?: string;
+  siteUrl?: string;
+  title?: string;
+  description?: string;
+}): Promise<string>;
+//#endregion
+export { ALLOWED_CHILDREN_MAP, AgentMarkdownOptions, ApiDocumentationBlock, ApiDocumentationBlockProps, type AuthAdapter, BLOG_POST_DEFINITION, type BadgeProps, BaseBlock, BlockDefinition, BlockDiff, BlockRegistry, BlockType, Byline, BylineCredit, BylineRole, CARD_DEFINITION, CHARACTER_DEFINITION, CMS_MCP_TOOLS, CacheHint, CachePurgeOptions, CalloutBlock, CalloutBlockProps, CalloutVariant, CardBlock, CardBlockProps, CardsBlock, CardsBlockProps, type CmsAuthAdapter, CmsCronResult, CmsEntry, CmsLoaderOptions, CmsPageData, CodeBlock, CodeBlockProps, ComponentShowcaseBlock, ComponentShowcaseBlockProps, DEFAULT_SITE_SETTINGS, DOCUMENT_DEFINITION, DialogueBlock, DialogueBlockProps, DiffChangeType, DocEntry, DocsConfig, EditLinkConfig, ExcerptOptions, FieldDefinition, FieldType, FileTreeBlock, FileTreeBlockProps, FileTreeNode, GROUP_DEFINITION, HERO_DEFINITION, HeadingLevel, ITEM_DEFINITION, ImageBlock, ImageBlockProps, InlineNode, InlineNodeType, InsertSiteSettings, LOCATION_DEFINITION, LinkInlineNode, LivePreviewBlock, LivePreviewBlockProps, Localized, MAX_SECTION_DEPTH, MAX_SECTION_HEADING_LEVEL, MIN_SECTION_HEADING_LEVEL, MediaValue, NewByline, OBJECT_DEFINITION, PAGE_MAP, PATCH_NOTE_DEFINITION, POSTGRES_SEARCH_CONFIGS, PageContent, PageDefinition, PageMentionNode, PageMetadata, PageTemplate, PageType, PageVersion, PageVersionApproval, PageVersionComment, PageVersionDiff, PageVersionStatus, ParagraphBlock, ParagraphBlockProps, PropertyGroup, R2StorageOptions, RegisterPageTypes, ResolvedScope, ResolvedSidebarItem, type RimelightCmsOptions, SERIES_DEFINITION, SKILL_DEFINITION, SPECIES_DEFINITION, SceneBlock, SceneBlockProps, ScriptBlock, ScriptBlockProps, SectionBlock, SectionBlockProps, Setting, type SidebarItem, type SidebarScope, SiteSettings, SiteSettingsBranding, SiteSettingsSeo, StepItemBlock, StepItemBlockProps, StepsBlock, StepsBlockProps, StorageConfig, StorageFile, StorageListOptions, StorageListResult, StorageUploadOptions, TabItemBlock, TabItemBlockProps, TableBlock, TableBlockProps, TableColumnDef, TableOfContentsConfig, TableOfContentsHeading, TabsBlock, TabsBlockProps, TaxonomyQueryOptions, TaxonomyTerm, TemplateApprovalRules, TemplateRolePermissions, TextInlineNode, TimeOfDay, type Toast, type ToastInput, type ToastItem, Transition, TypedBlock, TypedSceneBlockProps, TypedScriptBlockProps, UserSessionContext, type UserType, addToast, assignEntryTerms, auth0Auth, blocksToMarkdown, bylines, calculateHeadingLevel, canUserCreateFromTemplate, canUserEditBlock, canUserEditFromTemplate, canUserInstantiateTemplate, canUserReviewFromTemplate, canUserViewFromTemplate, cfAccessAuth, clearToasts, cmsAc, cmsStatements, contentSearchIndex, createByline, createPageExcerpt, createTerm, defineDocsConfig, definePageDefinition, deleteByline, deleteR2File, deleteTerm, diffBlocks, diffPageSnapshots, evaluateAccess, extractHeadingsFromBlocks, extractTextFromBlocks, filterBlocksForReader, filterTemplatesForUser, formatDocsUrl, generatePreviewToken, getByline, getBylines, getCmsCollection, getCmsEntry, getDocsSidebar, getDocsVersions, getEntriesByTerm, getEntryTerms, getPageDefinition, getPostgresSearchConfig, getR2Bucket, getSiteSettings, getSurroundItems, getTaxonomyTerms, getTerm, handleCmsCron, handleCmsMcpRequest, hasLockedDescendants, hasPermission, hasRole, indexPageForSearch, inlinesToMarkdown, invalidatePageCache, isValidUUID, listR2Files, mockAuth, pageDraftLocks, pageDrafts, pageTaxonomyTerms, pageTemplates, pageVersionApprovals, pageVersionComments, pageVersions, pages, parseDocsSlug, r2, removeToast, renderCorpusMarkdown, renderPageAsMarkdown, rimelightCms, rimelightCmsLoader, showErrorToast, showSuccessToast, siteSettings, slugifyHeading, taxonomyTerms, toast, toasts, updateByline, updateSiteSettings, updateTerm, uploadR2File, validateBlockAST, validateServerBlockPayload, verifyPreviewToken };