@bettercms-ai/next 0.5.2

package/dist/index.d.ts

@@ -0,0 +1,516 @@
+import { PageMetaJson, ContentBlock, SiteSeoDefaults, DeliveryComponent } from '@bettercms-ai/types';
+export { PageMetaJson, SiteSeoDefaults } from '@bettercms-ai/types';
+import { Metadata } from 'next';
+import { SeoInput, DeliveryForm } from '@bettercms-ai/sdk';
+export { ResolvedSeo, SeoInput, resolveSeo } from '@bettercms-ai/sdk';
+export { ImageFit, ImageFormat, ImageSource, ImageUrlBuilder, imageUrl, default as imageUrlBuilder } from '@bettercms-ai/image-url';
+import { ContentBlock as ContentBlock$1, DeliveryComponent as DeliveryComponent$1 } from '@betttercms/types';
+import { DeliveryForm as DeliveryForm$1 } from '@betttercms/sdk';
+
+/**
+ * Public types for @bettercms-ai/next.
+ *
+ * `BetterCMSEntry` mirrors the envelope emitted by @bettercms-ai/codegen's generated
+ * file. The adapter normalizes the raw Delivery API response into exactly this shape,
+ * so `getEntry`/`listEntries` line up 1:1 with your generated model types.
+ */
+/** Normalized error thrown by adapter reads. Mirrors the SDK's BetterCMSError, but kept
+ * local so the adapter carries no heavy runtime dependency into a consumer's bundle. */
+declare class BetterCMSError extends Error {
+    readonly status: number;
+    readonly code: string;
+    constructor(message: string, status: number, code: string);
+}
+/**
+ * Delivery envelope around a model's typed `fields`. Returned by `getEntry`/`listEntries`.
+ * Identical to the `BetterCMSEntry<TFields>` your generated types declare.
+ *
+ * `publishedAt`/`updatedAt` are ISO-8601 strings, or `null` when absent — never a
+ * fabricated empty string (so `new Date(...)` is safe to attempt only on non-null).
+ */
+interface BetterCMSEntry<TFields> {
+    readonly slug: string;
+    readonly status: "draft" | "published";
+    readonly fields: TFields;
+    readonly publishedAt: string | null;
+    readonly updatedAt: string | null;
+}
+interface BetterCMSConfig {
+    /** Workspace slug — the `:workspace` segment of the Delivery API path. */
+    workspace: string;
+    /** Optional delivery API key (sent as `Authorization: Bearer`). */
+    apiKey?: string;
+    /** Delivery API base. Default: `https://api.bettercms.ai/api/v1/delivery`. */
+    baseUrl?: string;
+    /** Preview API base. Default: derived from `baseUrl` (`/delivery` → `/preview`). */
+    previewBaseUrl?: string;
+    /**
+     * Default Next.js revalidation for reads (seconds). `false` = always fresh
+     * (`cache: "no-store"`). Per-call `revalidate` overrides this. Default: `60`.
+     */
+    revalidate?: number | false;
+}
+/** Per-read options shared by `getEntry` and `listEntries`. */
+interface ReadOptions {
+    /** ISR window in seconds, or `false` for `cache: "no-store"`. Overrides config default. */
+    revalidate?: number | false;
+    /** Next.js cache tags for on-demand `revalidateTag()` invalidation. */
+    tags?: string[];
+    /** Reference hydration depth (0 = none, 1 = direct refs, 2 = nested). */
+    depth?: 0 | 1 | 2;
+    /** Field projection — only these field keys are returned. */
+    select?: string[];
+}
+/** Options for `getEntry`, including draft-preview access. */
+interface GetEntryOptions extends ReadOptions {
+    /** Fetch draft content via the preview endpoint. Requires `previewToken`. */
+    preview?: boolean;
+    /** Signed preview token (from `POST .../preview-token`). */
+    previewToken?: string;
+}
+/** Options for `listEntries`. */
+interface ListEntriesOptions extends ReadOptions {
+    /** 1-based page number. Default: 1. */
+    page?: number;
+    /** Items per page (max 100). Default: 20. */
+    perPage?: number;
+}
+/** Paginated result returned by `listEntries`. */
+interface EntryList<TFields> {
+    items: BetterCMSEntry<TFields>[];
+    page: number;
+    perPage: number;
+    totalItems: number;
+    totalPages: number;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+}
+
+/**
+ * createBetterCMS — the Next.js delivery client.
+ *
+ * Reads run through the standard `fetch`, which the Next.js App Router patches to
+ * participate in the data cache. We pass `next: { revalidate, tags }` so content is
+ * cached/ISR'd and can be invalidated on publish via `revalidateTag()`.
+ *
+ * The raw Delivery API response is normalized into `BetterCMSEntry<TFields>` so the
+ * return types match what @bettercms-ai/codegen generates.
+ */
+
+/** A published page with its block_json — feed `blocks` to `<BcmsBlocks>`.
+ * The SEO fields (FLO-302) feed `buildMetadata` for the route's `generateMetadata`. */
+interface BetterCMSPage {
+    slug: string;
+    title: string;
+    metaTitle: string | null;
+    metaDescription: string | null;
+    /** Rich SEO (OG / Twitter / canonical / JSON-LD). `null` when unset. */
+    metaJson: PageMetaJson | null;
+    blocks: ContentBlock[];
+    publishedAt: string | null;
+    updatedAt: string | null;
+}
+/**
+ * The typed BetterCMS reader for Next.js.
+ *
+ * @typeParam Schema - your generated `BetterCMSSchema` (slug → fields registry). When
+ * supplied, `listEntries("blog")` is typed by the model's fields and the model name
+ * autocompletes. Defaults to an open record so it also works untyped.
+ */
+interface BetterCMSNext<Schema extends Record<string, unknown>> {
+    /** Fetch one published entry by its content slug. Returns `null` when not found.
+     * Passing `select` narrows the result to `Partial<TFields>` (projection drops fields). */
+    getEntry<TFields = unknown>(slug: string, opts: GetEntryOptions & {
+        select: string[];
+    }): Promise<BetterCMSEntry<Partial<TFields>> | null>;
+    getEntry<TFields = unknown>(slug: string, opts?: GetEntryOptions): Promise<BetterCMSEntry<TFields> | null>;
+    /** List published entries, filtered to one model. Throws `BetterCMSError`
+     * (CONTENT_NOT_FOUND) for an unknown workspace/model — an empty model returns an
+     * empty page. Passing `select` narrows fields to `Partial`. */
+    listEntries<M extends keyof Schema & string>(model: M, opts: ListEntriesOptions & {
+        select: string[];
+    }): Promise<EntryList<Partial<Schema[M]>>>;
+    listEntries<M extends keyof Schema & string>(model: M, opts?: ListEntriesOptions): Promise<EntryList<Schema[M]>>;
+    listEntries<TFields = unknown>(model?: string, opts?: ListEntriesOptions): Promise<EntryList<TFields>>;
+    /** Fetch one published page (with its `blocks` for `<BcmsBlocks>`) by slug.
+     * Returns `null` when not found. */
+    getPage(slug: string, opts?: {
+        revalidate?: number | false;
+        tags?: string[];
+    }): Promise<BetterCMSPage | null>;
+}
+declare function createBetterCMS<Schema extends Record<string, unknown> = Record<string, unknown>>(config: BetterCMSConfig): BetterCMSNext<Schema>;
+
+/**
+ * buildMetadata — map a BetterCMS page's SEO onto a Next.js `Metadata` object.
+ *
+ * Wire it into a route's `generateMetadata` so per-page Meta Title / Description and
+ * the rich OG / Twitter / canonical the dashboard saves drive the live `<head>`:
+ *
+ *   import { createBetterCMS, buildMetadata } from "@bettercms-ai/next";
+ *   const bcms = createBetterCMS({ workspace: "acme" });
+ *
+ *   export async function generateMetadata({ params }): Promise<Metadata> {
+ *     const page = await bcms.getPage(params.slug);
+ *     if (!page) return {};
+ *     return buildMetadata(page, siteDefaults);   // siteDefaults optional
+ *   }
+ *
+ * JSON-LD isn't part of Next's `Metadata`; render `resolveSeo(page, defaults).jsonLd`
+ * as a `<script type="application/ld+json">` in the page component (see the README).
+ *
+ * The merge (page-over-site) is delegated to `resolveSeo` (@bettercms-ai/sdk), the same
+ * resolver the Astro adapter uses — so every surface stays consistent.
+ */
+
+/** Build a Next.js `Metadata` from a BetterCMS page, layering page meta over site defaults. */
+declare function buildMetadata(page: SeoInput, siteDefaults?: SiteSeoDefaults): Metadata;
+
+/**
+ * Build-time content snapshot — the writer + reader of `bcms-content.json`.
+ *
+ * Why this exists: a static (`output: "export"`) build must resolve all content at
+ * build time. If a page instead falls back to a live `cache: "no-store"` fetch, its
+ * route becomes dynamic and `output: "export"` silently drops it — you get an empty
+ * `out/`. The fix is a single build-time snapshot the pages read synchronously.
+ *
+ * The WRITER (`buildSnapshot`/`writeSnapshot`, used by the `bettercms-snapshot` bin)
+ * and the READER (`getContent`) share ONE serializer (`serializeSnapshot`/
+ * `parseSnapshot`) so the on-disk shape can never drift between the two halves.
+ *
+ * This is intentionally separate from {@link createBetterCMS}: that stays the live,
+ * network-backed client. `getContent` is the snapshot-preferring reader a static
+ * site uses. Existing consumers that deliberately rely on the live fallback are
+ * unaffected — only `getContent` enforces "snapshot or bust".
+ */
+
+/** Bump when the on-disk shape changes incompatibly — readers reject mismatches. */
+declare const SNAPSHOT_VERSION = 1;
+/** Default snapshot filename, resolved against `process.cwd()`. */
+declare const DEFAULT_SNAPSHOT_FILE = "bcms-content.json";
+/** The full-site content snapshot. Entries are grouped by model slug so the reader
+ * can serve `listEntries(model)` offline without a per-entry model tag. */
+interface ContentSnapshot {
+    version: number;
+    workspace: string;
+    generatedAt: string;
+    models: Record<string, BetterCMSEntry<unknown>[]>;
+}
+/** Serialize a snapshot to the canonical JSON form written to disk. */
+declare function serializeSnapshot(snapshot: ContentSnapshot): string;
+/** Parse + validate a snapshot JSON string. Throws on a version mismatch so a stale
+ * snapshot fails loudly rather than feeding the build the wrong shape. */
+declare function parseSnapshot(json: string): ContentSnapshot;
+/** Write a snapshot to `path` (relative paths resolve against cwd), creating dirs. */
+declare function writeSnapshot(path: string, snapshot: ContentSnapshot): void;
+/** Read + parse a snapshot from `path`. Returns `null` only when the file is absent;
+ * a present-but-corrupt/stale file throws (callers must not treat that as "missing"). */
+declare function readSnapshot(path: string): ContentSnapshot | null;
+/** Minimal client surface `buildSnapshot` needs — lets tests inject a fake. Kept
+ * non-generic so a simple fake (and the live client's matching overload) both fit. */
+type ListOnly = {
+    listEntries(model?: string, opts?: ListEntriesOptions): Promise<EntryList<unknown>>;
+};
+/**
+ * Page through every model's published entries and assemble a full-site snapshot.
+ * `modelSlugs` come from the Management API (`fetchModels`) so the snapshot covers
+ * exactly this project's schema. Pass `client` in tests; defaults to the live client.
+ */
+declare function buildSnapshot(opts: {
+    config: BetterCMSConfig;
+    modelSlugs: string[];
+    client?: ListOnly;
+    /** Stamped into `generatedAt`; injectable for deterministic tests. */
+    now?: string;
+}): Promise<ContentSnapshot>;
+/** Snapshot-backed content reader. Async so it can transparently fall back to the
+ * live client in preview without changing the call sites. */
+interface ContentSource {
+    getEntry<TFields = unknown>(slug: string): Promise<BetterCMSEntry<TFields> | null>;
+    listEntries<TFields = unknown>(model?: string): Promise<EntryList<TFields>>;
+}
+/**
+ * The reader a static site should use. In a normal (export) build it reads the
+ * memoized `bcms-content.json` and serves entries from memory. If the snapshot is
+ * absent it THROWS a clear, actionable error — the whole point is to turn the old
+ * silent empty-`out/` failure into a loud build error. Set `BETTERCMS_PREVIEW=1`
+ * for a preview build that reads live instead.
+ */
+declare function getContent<Schema extends Record<string, unknown> = Record<string, unknown>>(config: BetterCMSConfig, opts?: {
+    snapshotPath?: string;
+}): ContentSource;
+
+/**
+ * llms.txt generation — the AI-discovery surface of the deterministic floor.
+ *
+ * `generateLlmsTxt` is pure (models in → string out), so it is trivially testable and
+ * deterministic. `llmsTxtRoute` wraps it as an App Router `route.ts` handler. `fetchModels`
+ * pulls the live schema from the Management API for sites that want a self-updating file.
+ *
+ * Output follows the llmstxt.org convention: an H1 title, a `>` summary, then sections.
+ */
+/** Minimal field shape needed to describe a model in llms.txt. */
+interface LlmsModelField {
+    key: string;
+    label?: string;
+    type: string;
+    required?: boolean;
+}
+/** Minimal model shape — a subset of the Management API model row. */
+interface LlmsModel {
+    slug: string;
+    name?: string;
+    description?: string | null;
+    fields: LlmsModelField[];
+}
+interface LlmsTxtOptions {
+    /** H1 title. Default: "BetterCMS content". */
+    title?: string;
+    /** One-line `>` summary under the title. */
+    description?: string;
+    /** Delivery API base used to render example endpoints. */
+    baseUrl?: string;
+    /** Workspace slug used in example endpoints. */
+    workspace?: string;
+    /** Extra free-form lines appended under a "## Notes" section. */
+    notes?: string[];
+}
+/**
+ * Render an llms.txt document describing the available content models. Deterministic:
+ * models are sorted by slug; field order is preserved as authored.
+ */
+declare function generateLlmsTxt(models: LlmsModel[], opts?: LlmsTxtOptions): string;
+/** Options for {@link llmsTxtRoute}. Provide one of `models` or `getModels`. */
+interface LlmsTxtRouteConfig extends LlmsTxtOptions {
+    /** Static model list (e.g. fetched at build time). */
+    models?: LlmsModel[];
+    /** Dynamic provider — called per request (wrap in your own caching if needed). */
+    getModels?: () => Promise<LlmsModel[]> | LlmsModel[];
+    /** Cache-Control header value. Default: `public, max-age=3600`. */
+    cacheControl?: string;
+}
+/**
+ * Build an App Router route handler that serves llms.txt as `text/plain`.
+ *
+ * ```ts
+ * // app/llms.txt/route.ts
+ * import { llmsTxtRoute } from "@bettercms-ai/next";
+ * export const GET = llmsTxtRoute({ models, title: "Acme", workspace: "acme" });
+ * ```
+ */
+declare function llmsTxtRoute(config: LlmsTxtRouteConfig): () => Promise<Response>;
+/**
+ * Fetch content models from the Management API (`GET /management/content/models`).
+ * The key is project-scoped server-side, so this returns exactly this site's schema.
+ * Dependency-free so it runs in any runtime (Edge route, build script, Node).
+ */
+declare function fetchModels(opts: {
+    /** Management API base, e.g. "https://api.bettercms.ai/api/v1". */
+    apiUrl: string;
+    /** A management-scoped key (content:manage). */
+    apiKey: string;
+    /** Optional fetch override (testing / custom runtime). */
+    fetchImpl?: typeof fetch;
+}): Promise<LlmsModel[]>;
+
+/**
+ * Draft-preview helpers. `next/headers` is imported dynamically so this module is safe
+ * to load outside a Next.js request scope (tests, build scripts) without throwing.
+ */
+/** True when Next.js Draft Mode is enabled for the current request. */
+declare function isDraftEnabled(): Promise<boolean>;
+/**
+ * The preview token stored by `createDraftModeRoute`, or null. Pass it to
+ * `getEntry(slug, { preview: true, previewToken })` to read drafts.
+ */
+declare function getPreviewToken(): Promise<string | null>;
+
+/**
+ * createDraftModeRoute — an App Router route-handler factory for entering draft
+ * preview. Mount it at e.g. `app/api/draft/route.ts`:
+ *
+ *   import { createDraftModeRoute } from "@bettercms-ai/next";
+ *   export const { GET } = createDraftModeRoute({ apiUrl: "https://api.bettercms.ai" });
+ *
+ * Visiting `/api/draft?token=<jwt>&redirect=/path` validates the preview token
+ * against the backend (the signature authority), enables Next Draft Mode, stores
+ * the token in an httpOnly cookie, and redirects. Reads can then pass the token
+ * via `getPreviewToken()` to `getEntry({ preview: true, previewToken })`.
+ */
+declare const PREVIEW_TOKEN_COOKIE = "bcms-preview-token";
+interface DraftModeRouteConfig {
+    /** Backend base, e.g. `https://api.bettercms.ai`. */
+    apiUrl: string;
+}
+declare function createDraftModeRoute(config: DraftModeRouteConfig): {
+    GET: (request: Request) => Promise<Response>;
+};
+/** Exit draft mode and clear the preview-token cookie. */
+declare function createDisableDraftRoute(): {
+    GET: (request: Request) => Promise<Response>;
+};
+
+/**
+ * Build-time reader for the forms the deploy Action injects into the content
+ * snapshot (schema "bcms-content/v1": `{ ...collections, forms, turnstileSiteKey }`).
+ *
+ * This is intentionally separate from `readSnapshot()` — that reads the
+ * `@bettercms-ai/next` "bettercms-snapshot" format (`{ version, models }`), which is a
+ * different file shape. Connected-repo sites on <name>.bettercms.site get the Action
+ * snapshot, so forms live here. Server/build-time only (uses node:fs).
+ */
+
+interface SnapshotForms {
+    forms: DeliveryForm[];
+    /** Public Turnstile site key for any form with `turnstileEnabled`, or null. */
+    turnstileSiteKey: string | null;
+}
+/**
+ * Read forms from the Action's `bcms-content.json`. Missing file or no forms →
+ * an empty set (a content-only build never throws). `path` resolves against cwd.
+ */
+declare function readForms(path?: string): SnapshotForms;
+/** Find a single form by `id` or `name` from the Action snapshot. */
+declare function getForm(idOrName: string, path?: string): DeliveryForm | undefined;
+
+/**
+ * Build-time reader for the pages the deploy Action injects into the content
+ * snapshot (schema "bcms-content/v1": `{ ...collections, forms, pages, turnstileSiteKey }`).
+ *
+ * Sibling to `forms-read.ts`. Connected-repo sites on <name>.bettercms.site get the
+ * Action snapshot, so published pages (with their block_json) live here. Render a page
+ * with `<BcmsBlocks blocks={page.blocks} forms={readForms().forms} />`. The same data
+ * is also available at runtime via `createBetterCMS(...).getPage(slug)`.
+ * Server/build-time only (uses node:fs).
+ */
+
+interface SnapshotPage {
+    slug: string;
+    title: string;
+    metaTitle: string | null;
+    metaDescription: string | null;
+    /** Rich SEO (OG / Twitter / canonical / JSON-LD) — FLO-302. Feed to `buildMetadata`. */
+    metaJson: PageMetaJson | null;
+    /** The page's block_json — pass to `<BcmsBlocks blocks={...} />`. */
+    blocks: ContentBlock[];
+    updatedAt: string | null;
+    publishedAt: string | null;
+}
+/**
+ * Read published pages from the Action's `bcms-content.json`. Missing file or no
+ * pages → an empty list (a pages-less build never throws). `path` resolves against cwd.
+ */
+declare function readPages(path?: string): SnapshotPage[];
+/** Find a single published page by `slug` from the Action snapshot. */
+declare function getPage(slug: string, path?: string): SnapshotPage | undefined;
+
+/**
+ * Build-time reader for the reusable components the deploy Action injects into the
+ * content snapshot (`bcms-content.json` → `components`). Mirrors `forms-read.ts`.
+ *
+ * Pass the result to `<BcmsBlocks components={readComponents()} … />` so `component`
+ * blocks resolve their definitions. Server/build-time only (uses node:fs).
+ */
+
+/**
+ * Read components from the Action's `bcms-content.json`. Missing file or no
+ * components → an empty array (a content-only build never throws).
+ */
+declare function readComponents(path?: string): DeliveryComponent[];
+/** Find a single component by `id`, `slug`, or `name` from the Action snapshot. */
+declare function getComponent(idOrSlug: string, path?: string): DeliveryComponent | undefined;
+
+/**
+ * <BcmsForm> — render a BetterCMS form natively in React, the headless way.
+ *
+ * Pass a form straight from your content snapshot (`readSnapshot().forms[n]`) or
+ * the delivery API. It renders real inputs (no iframe), handles conditional
+ * `showIf` fields, URL-query prefill, the honeypot, an optional Turnstile widget,
+ * and submits via `@bettercms-ai/sdk`'s `submitForm`. All visible markup is
+ * unstyled and class-driven, so the host site owns the look.
+ */
+
+interface BcmsFormProps {
+    /** A form from your content snapshot or the delivery API. */
+    form: DeliveryForm;
+    /** API origin. Defaults to the SDK default (https://api.bettercms.ai). */
+    apiBase?: string;
+    /** Turnstile site key — needed to render the widget when `form.turnstileEnabled`. */
+    turnstileSiteKey?: string;
+    /** Called with the new submission id after a successful submit (before any redirect). */
+    onSubmitted?: (submissionId: string) => void;
+    /** Class for the <form> element; field wrappers/status use `bcms-*` classes. */
+    className?: string;
+}
+
+/**
+ * <BcmsBlocks> — render a BetterCMS page's block_json natively in React.
+ *
+ * Pass the `blocks` from a page (delivery API `/content/:slug` → `entry.blocks`)
+ * plus the `forms` you read with `readForms()`. Every block type renders to plain,
+ * class-driven markup (the host site owns the styling); a `form` block resolves its
+ * `formId` against `forms` and renders `<BcmsForm>` inline exactly where the user
+ * placed it in the page builder. This is the turnkey "Webflow" path — forms show up
+ * wherever they were dropped on the page, with no manual wiring.
+ *
+ * Ships from its own "use client" entry (like <BcmsForm>) so it can be rendered from
+ * a Next App Router Server Component without breaking the RSC boundary.
+ */
+
+interface BcmsBlocksProps {
+    /** A page's blocks (delivery API `/content/:slug` → `entry.blocks`). */
+    blocks: ContentBlock$1[];
+    /** Forms available to `form` blocks — from `readForms().forms`. */
+    forms?: DeliveryForm$1[];
+    /** Reusable components available to `component` blocks — from `readComponents()`. */
+    components?: DeliveryComponent$1[];
+    /** Turnstile site key — forwarded to `<BcmsForm>` for form blocks. */
+    turnstileSiteKey?: string;
+    /** API origin forwarded to `<BcmsForm>`. Defaults to the SDK default. */
+    apiBase?: string;
+    /** Class for the wrapping <div>. */
+    className?: string;
+}
+
+interface BcmsLiveProps {
+    /** Live SSE URL, e.g. from `defineBetterCMSLive().liveSrc`. */
+    src: string;
+    /** Refresh the route on each change event. Default true. */
+    refreshOnChange?: boolean;
+    /** Optional callback for custom handling (e.g. targeted revalidation). */
+    onChange?: (event: {
+        type: string;
+        slug: string;
+        tags: string[];
+    }) => void;
+}
+
+/**
+ * defineBetterCMSLive — build the live SSE URL for `<BcmsLive>` from your config.
+ * Server-safe (no React); pass the returned `liveSrc` to the client component.
+ */
+interface BetterCMSLiveConfig {
+    /** Backend base, e.g. `https://api.bettercms.ai`. */
+    apiUrl: string;
+    workspace: string;
+    /** A content:read key — exposed to the browser via the SSE URL query. */
+    apiKey: string;
+}
+declare function defineBetterCMSLive(config: BetterCMSLiveConfig): {
+    liveSrc: string;
+};
+
+interface RevalidateRouteConfig {
+    /** Shared secret matching the project's revalidation webhook secret. */
+    secret?: string;
+}
+declare function createRevalidateRoute(config?: RevalidateRouteConfig): {
+    POST: (request: Request) => Promise<Response>;
+};
+
+interface VisualEditingProps {
+    /** Dashboard base for deep links. Defaults to https://dashboard.bettercms.ai. */
+    studioUrl?: string;
+}
+
+export { type BcmsBlocksProps, type BcmsFormProps, type BcmsLiveProps, type BetterCMSConfig, type BetterCMSEntry, BetterCMSError, type BetterCMSLiveConfig, type BetterCMSNext, type BetterCMSPage, type ContentSnapshot, type ContentSource, DEFAULT_SNAPSHOT_FILE, type DraftModeRouteConfig, type EntryList, type GetEntryOptions, type ListEntriesOptions, type LlmsModel, type LlmsModelField, type LlmsTxtOptions, type LlmsTxtRouteConfig, PREVIEW_TOKEN_COOKIE, type ReadOptions, type RevalidateRouteConfig, SNAPSHOT_VERSION, type SnapshotForms, type SnapshotPage, type VisualEditingProps, buildMetadata, buildSnapshot, createBetterCMS, createDisableDraftRoute, createDraftModeRoute, createRevalidateRoute, defineBetterCMSLive, fetchModels, generateLlmsTxt, getComponent, getContent, getForm, getPage, getPreviewToken, isDraftEnabled, llmsTxtRoute, parseSnapshot, readComponents, readForms, readPages, readSnapshot, serializeSnapshot, writeSnapshot };