@justanarthur/payload-www 0.1.1

package/dist/server.d.ts

@@ -0,0 +1,922 @@
+import { Block as Block3, CollectionConfig as CollectionConfig4, Config, GlobalConfig as GlobalConfig3, Plugin } from "payload";
+import { Metadata, MetadataRoute } from "next";
+import { DataFromCollectionSlug, ImportMap, SanitizedConfig } from "payload";
+import { ReactElement, ReactNode } from "react";
+type ArticleLdOptions = {
+	doc: Record<string, any>;
+	url: string;
+	locale: string;
+	siteUrl: string;
+	type?: "BlogPosting" | "Article" | "NewsArticle" | "TechArticle";
+	publisherName?: string;
+	publisherLogo?: string | null;
+};
+declare function buildArticleLd({ doc, url, locale, siteUrl, type, publisherName, publisherLogo }: ArticleLdOptions): Record<string, unknown>;
+type BreadcrumbItem = {
+	label: string;
+	url: string;
+};
+declare function buildBreadcrumbsLd({ items, currentUrl }: {
+	items: BreadcrumbItem[];
+	currentUrl: string;
+}): Record<string, unknown>;
+declare function buildOrganizationLd({ siteUrl, name, logo, sameAs }: {
+	siteUrl: string;
+	name?: string;
+	logo?: string;
+	sameAs?: string[];
+}): Record<string, unknown>;
+type PageExtendProps = {
+	importMap: ImportMap;
+	config: SanitizedConfig;
+	locale: string;
+};
+type ArticleJsonLdEntry = {
+	type: "article";
+	id?: string;
+	schemaType?: "BlogPosting" | "Article" | "NewsArticle" | "TechArticle";
+	publisherName?: string;
+	publisherLogo?: string | null;
+};
+type WebSiteJsonLdEntry = {
+	type: "website";
+	id?: string;
+	name?: string;
+	alternateName?: string;
+};
+type OrganizationJsonLdEntry = {
+	type: "organization";
+	id?: string;
+	name?: string;
+	logo?: string;
+	sameAs?: string[];
+};
+type BreadcrumbsJsonLdEntry = {
+	type: "breadcrumbs";
+	id?: string;
+	items?: BreadcrumbItem[];
+	buildItems?: (doc: DataFromCollectionSlug<string>, url: string) => BreadcrumbItem[];
+};
+type CustomJsonLdEntry = {
+	type: "custom";
+	id?: string;
+	build: (ctx: {
+		doc: DataFromCollectionSlug<string>;
+		url: string;
+		locale: string;
+		siteUrl: string;
+	}) => Record<string, unknown>;
+};
+type JsonLdEntry = ArticleJsonLdEntry | WebSiteJsonLdEntry | OrganizationJsonLdEntry | BreadcrumbsJsonLdEntry | CustomJsonLdEntry;
+type JsonLdOutput = {
+	id: string;
+	schema: Record<string, unknown>;
+};
+/**
+* Minimal next-intl routing contract the lib reads. Hosts pass
+* their `defineRouting({...})` result directly; the lib only needs
+* the shape below.
+*
+* `localePrefix` accepts either the simple string form
+* (`'always' | 'as-needed' | 'never'`) or next-intl's verbose
+* `LocalePrefixConfigVerbose` shape (`{ mode, prefixes? }`). The lib
+* normalizes both to a string `mode` internally.
+*/
+type LocalePrefixValue = "always" | "as-needed" | "never" | {
+	mode?: "always" | "as-needed" | "never";
+};
+type PageRouting = {
+	locales: readonly string[];
+	defaultLocale: string;
+	localePrefix?: LocalePrefixValue;
+	/** Optional human-readable labels per locale (used by the
+	* `<LocaleSwitcher>`). Falls back to the locale code when missing.
+	* Not part of next-intl's `defineRouting` shape — the host extends
+	* its routing object to include it (e.g. via a type assertion). */
+	labels?: Record<string, string>;
+};
+type MetadataOptions = {
+	urlPrefix?: string;
+	/** When true (default), the lib generates a `{type:'website'}` JSON-LD
+	* entry per page. Pass an array to specify entries; pass `false` to
+	* skip. */
+	jsonLd?: boolean | JsonLdEntry[];
+	changefreq?: MetadataRoute.Sitemap[number]["changeFrequency"];
+	priority?: number;
+	/**
+	* Override the default `'website'` JSON-LD's `name` field. Only
+	* relevant when `jsonLd !== false` and no `name` is set on the
+	* auto-generated entry.
+	*/
+	websiteName?: string;
+};
+type ShowcaseOptions = {
+	/**
+	* Wrap the rendered page in a two-column layout with a sidebar
+	* that surfaces the page's metadata, JSON-LD, and a language
+	* switcher. Hosts that want a clean render (no sidebar) leave
+	* this `false` (the default). The demo's home page enables it
+	* so visitors can see every artifact the lib generates in one
+	* place.
+	*/
+	enabled?: boolean;
+	/** Heading shown above the metadata block. Default: `'Page metadata'`. */
+	metadataHeading?: string;
+	/** Heading shown above the JSON-LD block. Default: `'JSON-LD'`. */
+	jsonLdHeading?: string;
+};
+type CreateCollectionPageExportsArgs<S extends string = "pages"> = {
+	config: Promise<SanitizedConfig>;
+	/**
+	* Defaults to `'pages'`. The collection slug whose documents the
+	* page route renders.
+	*/
+	slug?: S;
+	/**
+	* The next-intl `defineRouting({...})` result from the host's
+	* `i18n/routing.ts`. Drives locale validation, URL building,
+	* hreflang alternates, and the language switcher.
+	*/
+	routing: PageRouting;
+	/**
+	* The host's Payload importMap. The lib uses this to resolve
+	* the collection's `custom.path` (the page renderer module) and
+	* the live-preview listener. Pass `import { importMap } from
+	* '@/app/(payload)/admin/importMap.js'` from the host's page
+	* file. Default: `{}` — the page renders without a live-preview
+	* listener and uses the lib's registered `custom.path` for the
+	* collection renderer (which requires its key to be in the
+	* supplied importMap).
+	*/
+	importMap?: ImportMap;
+	/**
+	* Optional custom path pointing at the host's render module for
+	* the collection. Overrides the lib's registered `custom.path`
+	* (which defaults to `PAGES_RENDER_PATH`). Use this when you've
+	* defined your own Server Component for the collection.
+	*/
+	renderPath?: string;
+};
+type CreateCollectionPageExportsDeps<S extends string> = {
+	/**
+	* Host's `getServerSideURL()` (returns the absolute site URL).
+	*/
+	getServerSideURL: () => string;
+	/**
+	* Host's `generateMeta({ doc, url, type, locale })` (returns Next.js
+	* `Metadata`). The `doc` is the host's typed collection document
+	* (e.g. `Post` for the posts collection, `Page` for pages) with
+	* localized fields already resolved for the active locale. Read
+	* `doc.title` directly as a string — no locale-lookup needed.
+	*/
+	generateMeta: (args: {
+		doc: DataFromCollectionSlug<S> | null;
+		url: string;
+		type: "website" | "article";
+		locale: string;
+	}) => Promise<Metadata>;
+	/**
+	* Override the metadata type passed to `generateMeta` and the
+	* JSON-LD entry default. Defaults to `'article'` for the
+	* `posts` collection, `'website'` everywhere else. Hosts that
+	* want to opt out (e.g. treat a Post like a WebPage) pass
+	* `'website'` explicitly here.
+	*/
+	metadataType?: "website" | "article";
+	/**
+	* Optional showcase configuration. When `enabled: true`, the
+	* default page renders inside a `<PageShowcase>` sidebar that
+	* surfaces the page's metadata, JSON-LD, and a language
+	* switcher — useful for demos and CMS previews. Default: off.
+	*/
+	showcase?: ShowcaseOptions;
+	/**
+	* Optional content injected after the rendered doc body when the
+	* page is the home route (slug = `''`). The lib calls the
+	* function with the resolved locale and the current doc (or
+	* `null` if no home doc exists). Hosts that want the home to
+	* surface additional content — recent pages, recent posts,
+	* navigation — pass a function here. The return value is
+	* rendered as a sibling of the lib's doc body inside the page
+	* (and inside the showcase's main column when showcase is on).
+	*/
+	homeExtras?: (args: {
+		locale: string;
+		doc: DataFromCollectionSlug<S> | null;
+	}) => ReactNode | Promise<ReactNode>;
+};
+/**
+* Build a Pages (or any collection) page route's exports:
+* `default` (the Page Server Component), `generateMetadata`,
+* `generateStaticParams`, and `generateSitemap`.
+*
+* Designed for a next-intl layout: the page lives at
+* `app/(frontend)/[locale]/[...slug]/page.tsx`. The catch-all slug
+* handles both the home route (slug=[]) and any other doc. The lib
+* reads `params.locale` and `params.slug` (string[]), validates
+* the locale against `routing.locales`, fetches the doc, generates
+* metadata + JSON-LD + hreflang alternates, and renders the
+* resolved output.
+*
+* The host's `next-intl/routing` config is the single source of
+* truth for the locale list and URL shape.
+*
+*   // app/(frontend)/[locale]/[...slug]/page.tsx
+*   import { routing } from '@/i18n/routing'
+*   import { createCollectionPageExports } from '@justanarthur/payload-www/render-pages'
+*
+*   const { default: Page, generateMetadata, generateStaticParams } =
+*     createCollectionPageExports(
+*       { config: configPromise, routing },
+*       { getServerSideURL, generateMeta, showcase: { enabled: true } }
+*     )
+*
+*   { generateMetadata, generateStaticParams }
+*   Page
+*/
+declare function createCollectionPageExports<S extends string = "pages">({ slug, config: configPromise, routing, importMap: importMapArg, renderPath }: CreateCollectionPageExportsArgs<S>, deps: CreateCollectionPageExportsDeps<S>, options?: MetadataOptions): {
+	default: (props: {
+		params: Promise<{
+			locale?: string;
+			slug?: string[];
+		}>;
+		searchParams?: Promise<Record<string, string | string[] | undefined>>;
+	}) => Promise<ReactElement>;
+	generateMetadata: (props: {
+		params: Promise<{
+			locale?: string;
+			slug?: string[];
+		}>;
+	}) => Promise<Metadata>;
+	generateStaticParams: () => Promise<Array<{
+		slug?: string[];
+		locale: string;
+	}>>;
+	generateSitemap: () => Promise<MetadataRoute.Sitemap>;
+	generateJsonLd: (slugSegments: string[], doc: DataFromCollectionSlug<S>, locale: string) => Promise<JsonLdOutput[]>;
+};
+declare function addCollectionsToSitemap(exports: Array<{
+	default: () => Promise<MetadataRoute.Sitemap>;
+	generateSitemap: () => Promise<MetadataRoute.Sitemap>;
+}>): {
+	default: () => Promise<MetadataRoute.Sitemap>;
+	generateSitemap: () => Promise<MetadataRoute.Sitemap>;
+};
+declare const STATIC_PAGES_SLUG = "staticPages";
+import { Block, CollectionConfig } from "payload";
+import { CollectionAfterChangeHook, CollectionAfterDeleteHook } from "payload";
+type LocalePrefixMode = "always" | "as-needed" | "never";
+type CreateRevalidateCollectionHookOptions = {
+	/**
+	* The collection's slug. Used in the per-collection tag fired
+	* alongside path invalidation: `collection_<slug>_<id>`.
+	*/
+	collectionSlug: string;
+	/**
+	* URL path prefix for this collection's rendered URLs. Pages use
+	* `''` (mounted at root); Posts use `'/posts'`. Leading slash,
+	* no trailing slash — same convention as
+	* `createSitemapFile.urlPrefixes`.
+	*/
+	urlPathPrefix?: string;
+	/**
+	* Sitemap tag the collection's revalidation hook invalidates on
+	* every save. Defaults to `${collectionSlug}-sitemap`. Pass
+	* `false` to opt out (collections without a sitemap handler).
+	*/
+	sitemapTag?: string | false;
+	/**
+	* Locale prefix mode — mirrors next-intl's `localePrefix`.
+	* Defaults to `'always'` (preserves legacy behavior).
+	*/
+	localePrefix?: LocalePrefixMode;
+	/**
+	* Default locale for `localePrefix: 'as-needed'`. Falls back to
+	* `req.payload.config.localization.defaultLocale` at request time
+	* when omitted.
+	*/
+	defaultLocale?: string;
+	/**
+	* Path invalidation strategy. Default: `'url'` — fans out
+	* `revalidatePath` for every locale × every slug. Set to
+	* `'tag-only'` for collections without a URL (e.g. `staticPages`
+	* — addressed by a `kind` discriminator, not a slug). Tag-only
+	* mode still fires the per-collection tag (via `sitemapTag`) and
+	* the per-id tag (`collection_<slug>_<id>`).
+	*/
+	pathMode?: "url" | "tag-only";
+};
+/**
+* Canonical factory for **all** collection revalidation hooks —
+* Pages, Posts, and any host-defined collection.
+*
+* Behavior:
+*
+* - Fires `revalidatePath` for **every** locale the host has
+*   declared (not just the request locale). The path is
+*   `${prefixFor(locale)}${urlPathPrefix}/${slug}` (or
+*   `${prefixFor(locale)}${urlPathPrefix}` for the home page with
+*   empty slug).
+* - Fires `revalidateTag(sitemapTag, 'max')` on every change /
+*   delete so the sitemap handler sees fresh data.
+* - Fires `revalidateTag('collection_<slug>_<id>', 'max')` so
+*   hosts using `unstable_cache` keyed by id stay fresh.
+* - Handles slug renames while published (fires both old and new
+*   paths across all locales).
+* - Respects `req.context.disableRevalidate` for seed / test
+*   scripts.
+*
+* Use `createRevalidateCollectionHook({ ... })` for any
+* collection. For Pages specifically, the lib still exposes
+* `createRevalidatePageHooks()` as a deprecated alias that
+* delegates to this factory with `collectionSlug: 'pages'` and
+* `urlPathPrefix: ''`.
+*/
+declare function createRevalidateCollectionHook(options: CreateRevalidateCollectionHookOptions): {
+	afterChange: CollectionAfterChangeHook;
+	afterDelete: CollectionAfterDeleteHook;
+};
+type CreateRevalidatePageHooksOptions = Omit<CreateRevalidateCollectionHookOptions, "collectionSlug" | "urlPathPrefix">;
+/**
+* @deprecated Use `createRevalidateCollectionHook({ collectionSlug: 'pages', urlPathPrefix: '' })` instead.
+* Kept so hosts that imported this name directly don't break — the
+* alias delegates to the canonical factory with the Pages preset.
+*/
+declare const createRevalidatePageHooks: (opts?: CreateRevalidatePageHooksOptions) => {
+	afterChange: CollectionAfterChangeHook;
+	afterDelete: CollectionAfterDeleteHook;
+};
+declare const HOME_PAGE_SLUG = "";
+declare const PAGES_SLUG = "pages";
+type CreatePagesCollectionOptions = {
+	/**
+	* Blocks the Pages collection accepts.
+	*/
+	blocks: Block[];
+	/**
+	* Optional override for the collection slug. Default: `'pages'`.
+	* Hosts that want a different slug (e.g. `'site_pages'`) pass
+	* it here. The lib's Header / Footer `linkRelationTo` default
+	* uses `'pages'` — combine this with a matching
+	* `linkRelationTo` to keep nav links targeting the right
+	* collection.
+	*/
+	slug?: string;
+	/**
+	* Optional override for the `custom.path` Payload uses to resolve
+	* the page's render module. Default: the lib's `PAGES_RENDER_PATH`
+	* (a Server Component that calls `RenderBlocks`). Use this when
+	* you've defined your own Server Component for the collection.
+	*/
+	renderPath?: string;
+	/**
+	* Locale prefix mode for path invalidation. Defaults to `'always'`
+	* (preserves current behavior). Set to `'as-needed'` when the host
+	* uses next-intl `localePrefix: 'as-needed'` — otherwise the hook
+	* invalidates paths the public routes don't use.
+	*/
+	localePrefix?: CreateRevalidateCollectionHookOptions["localePrefix"];
+	/**
+	* Default locale for prefix skipping. Falls back to
+	* `req.payload.config.localization.defaultLocale` at request time
+	* when omitted.
+	*/
+	defaultLocale?: CreateRevalidateCollectionHookOptions["defaultLocale"];
+};
+declare const createPagesCollection: (blocks: Block[], options?: Omit<CreatePagesCollectionOptions, "blocks">) => CollectionConfig;
+import { CollectionConfig as CollectionConfig2 } from "payload";
+declare const POSTS_SLUG = "posts";
+type CreatePostsCollectionOptions = {
+	/**
+	* Optional override for the collection slug. Default: `'posts'`.
+	* Hosts that want a different slug (e.g. `'articles'` or `'blog'`)
+	* pass it here. Combine with the page route's URL convention and
+	* the lib's translator plugin's `collections` list.
+	*/
+	slug?: string;
+	/**
+	* Override the `custom.path` Payload uses to resolve the post's
+	* render module. Defaults to the lib's `POSTS_RENDER_PATH`
+	* (the lib's `<PostsPage>` Server Component, which renders
+	* `title` + `excerpt` + Lexical `content`). Hosts that want a
+	* custom render pass their own Server Component's import path
+	* here (e.g. `'@/blog/Post#default'`).
+	*/
+	renderPath?: string;
+	/**
+	* Locale prefix mode for path invalidation. Defaults to `'always'`.
+	* Set to `'as-needed'` when the host uses next-intl
+	* `localePrefix: 'as-needed'` — otherwise the hook invalidates
+	* paths the public routes don't use.
+	*/
+	localePrefix?: "always" | "as-needed" | "never";
+	/**
+	* Default locale for prefix skipping. Falls back to
+	* `req.payload.config.localization.defaultLocale` at request time
+	* when omitted.
+	*/
+	defaultLocale?: string;
+};
+/**
+* Build the Posts collection. Posts have a simpler shape than
+* Pages: `title` + `excerpt` (both localized) + a Lexical `content`
+* rich text field. Hosts that want blocks can either swap the
+* `content` field for a `blocks` field via the returned config, or
+* define a custom Post shape entirely.
+*
+* The Posts collection exists primarily so the lib's translator
+* plugin has a second localized collection to translate.
+*/
+declare const createPostsCollection: (options?: CreatePostsCollectionOptions) => CollectionConfig2;
+import { Block as Block2, CollectionConfig as CollectionConfig3 } from "payload";
+type CreateStaticPagesCollectionOptions = {
+	/**
+	* Blocks the StaticPages collection accepts. Hosts pass the same
+	* `blocks` they use for `createPagesCollection` (or a smaller
+	* subset — e.g. just `pageHeroBlock` + `ctaBlock` + `featureGridBlock`).
+	* The lib does not curate a separate block set for system pages.
+	*/
+	blocks: Block2[];
+};
+declare const createStaticPagesCollection: (blocks: Block2[]) => CollectionConfig3;
+import { GlobalConfig } from "payload";
+type CreateHeaderGlobalOptions = {
+	/**
+	* Optional override for the `custom.path` Payload uses to resolve
+	* the header's render module. Default: the lib's `HEADER_RENDER_PATH`.
+	*/
+	renderPath?: string;
+	/**
+	* Collection slugs the nav's link fields can reference. Required
+	* by Payload 3.85 — empty `relationTo` arrays are rejected.
+	* Defaults to `['pages']` (the lib's Pages collection). Pass a
+	* different list when your host has additional linkable collections.
+	*/
+	linkRelationTo?: string[];
+};
+/**
+* Build the Header global. The lib's default shape: a `nav` blocks
+* field with two block types — `navColumn` (a titled group of links)
+* and `navItem` (a single link).
+*/
+declare const createHeaderGlobal: (options?: CreateHeaderGlobalOptions) => GlobalConfig;
+import { GlobalConfig as GlobalConfig2 } from "payload";
+type CreateFooterGlobalOptions = {
+	/**
+	* Optional override for the `custom.path` Payload uses to resolve
+	* the footer's render module. Default: the lib's `FOOTER_RENDER_PATH`.
+	*/
+	renderPath?: string;
+	/**
+	* Collection slugs the nav's link fields can reference. Required
+	* by Payload 3.85 — empty `relationTo` arrays are rejected.
+	* Defaults to `['pages']` (the lib's Pages collection). Pass a
+	* different list when your host has additional linkable collections.
+	*/
+	linkRelationTo?: string[];
+};
+/**
+* Build the Footer global. The lib's default shape mirrors the
+* Header: a `nav` blocks field with `navColumn` (a titled group of
+* links) and `navItem` (a single link) blocks.
+*/
+declare const createFooterGlobal: (options?: CreateFooterGlobalOptions) => GlobalConfig2;
+type WWWConfigOptions = {
+	/**
+	* Locales the host uses. First entry is the default locale
+	* (used for translation source-of-truth and the home-page path).
+	* The list drives hreflang alternates, sitemap, and the per-locale
+	* revalidation tag suffix.
+	*/
+	locales: string[];
+	/**
+	* The host's next-intl routing config (the value returned from
+	* `defineRouting({...})`). When passed, `locales`, `defaultLocale`,
+	* and `localePrefix` are read from this object instead of the
+	* legacy `locales: string[]` field. `localePrefix` is normalized
+	* to the simple string form internally — next-intl's verbose
+	* `{ mode, prefixes? }` shape is accepted and reduced to `mode`.
+	*/
+	routing?: PageRouting;
+	/**
+	* Blocks the Pages collection accepts.
+	*/
+	blocks: Block3[];
+	/**
+	* Collection slugs the Header / Footer nav `link` fields can
+	* reference. Defaults to `['pages']` (the lib's Pages collection).
+	* Pass a different list when your host has additional linkable
+	* collections.
+	*/
+	linkRelationTo?: string[];
+	/**
+	* Register the lib's Posts collection. Default: `true`. The
+	* translator plugin's default `collections` list is
+	* `['pages', 'posts']`; pass `false` here to opt out and either
+	* define your own posts-like collection or drop the translator.
+	*/
+	registerPosts?: boolean;
+	/**
+	* Final say on the lib's default plugin list. Receives the
+	* `[seoPlugin, imageHashPlugin, translator]` array; return the
+	* list to apply. Common uses: drop the translator (no AI
+	* translation in this project), add a second `seoPlugin({...})`
+	* call for posts, or layer on a `formBuilderPlugin(...)`.
+	*/
+	defaultPlugins?: (defaults: Plugin[]) => Plugin[];
+};
+type WWWConfigApi = {
+	withWWWConfig: (config: WWWInputConfig) => Promise<Config> | Config;
+};
+type WWWInputConfig = Omit<Config, "collections" | "globals"> & {
+	collections: ((args: {
+		defaultCollections: CollectionConfig4[];
+	}) => CollectionConfig4[]) | CollectionConfig4[];
+	globals: ((args: {
+		defaultGlobals: GlobalConfig3[];
+	}) => GlobalConfig3[]) | GlobalConfig3[];
+};
+/**
+* Build the lib's data-config API surface, configured for a specific host.
+*
+* Hosts call this once with their `locales` and `blocks`; the returned
+* object is **safe to import from a Node entrypoint** such as
+* `payload.config.ts` — it only contains Payload collection / global
+* factories and the `withWWWConfig` composer.
+*
+* The lib applies three plugins by default: `seoPlugin` (Pages + meta tab),
+* `imageHashPlugin` (Blurhash/Thumbhash on uploads), and `translator`
+* (auto-translation workflow). Use the `defaultPlugins` callback to
+* drop or extend the list.
+*
+* For the App Router rendering side, import from the lib's render
+* subpaths:
+*
+*   import { createCollectionPageExports } from '@justanarthur/payload-www/render-pages'
+*   import { createPreviewHandler, createSitemapFile } from '@justanarthur/payload-www/render-utils'
+*/
+declare function createWWWConfig(options: WWWConfigOptions): WWWConfigApi;
+import { Access } from "payload";
+declare const anyone: Access;
+declare const authenticated: Access;
+declare const authenticatedOrPublished: Access;
+import { GlobalAfterChangeHook } from "payload";
+/**
+* Build a tag-based revalidation hook for a global. Fires two tags
+* after a save:
+*
+* - `global_${slug}` — invalidates the lib's `getCachedGlobal` cache
+*   and any host caches that key by slug alone.
+* - `global_${slug}_${locale}` — invalidates per-locale cache slots
+*   for hosts that key by `[slug, locale]`.
+*
+* The hook fires both so the lib's single-slot cache and the
+* per-locale pattern both stay fresh regardless of which the host
+* uses.
+*/
+declare function createRevalidateGlobalHook(slug: string): GlobalAfterChangeHook;
+import { Field, GroupField } from "payload";
+type LinkAppearances = "default" | "outline";
+declare const appearanceOptions: Record<LinkAppearances, {
+	label: string;
+	value: string;
+}>;
+type LinkOptions = {
+	appearances?: LinkAppearances[] | false;
+	disableLabel?: boolean;
+	/**
+	* Collection slugs the link can reference. Payload 3.85 rejects
+	* empty arrays, so the lib defaults to `['pages']` (its own Pages
+	* collection). Hosts that reference different collections pass
+	* their own list.
+	*/
+	relationTo?: string[];
+	/** Mark the text fields as `localized: true`. */
+	localized?: boolean;
+	/** Deep-merge into the resulting group. */
+	overrides?: Partial<GroupField>;
+	/** Legacy alias for the host's custom field overrides. */
+	linkOverrides?: Partial<GroupField>;
+};
+declare const link: (options?: LinkOptions) => Field;
+import { Field as Field2 } from "payload";
+declare const linkGroup: (options?: LinkOptions) => Field2;
+import { ImportMap as ImportMap2 } from "payload";
+declare function getFromImportMap(key: string, importMap: ImportMap2): any;
+declare function generateImportName(type: "block" | "page", slug: string): string;
+import { ImportMap as ImportMap3 } from "payload";
+import { JSX as JSX_1kxb } from "react/jsx-runtime";
+type Element_12xgc = JSX_1kxb["Element"];
+declare function renderCollectionModule(collection: {
+	slug: string;
+	custom?: Record<string, any>;
+}[] | undefined, slug: string, importMap: ImportMap3, props?: Record<string, any>): Element_12xgc | null;
+import { ImportMap as ImportMap4 } from "payload";
+import { JSX as JSX_1kxb2 } from "react/jsx-runtime";
+type Element_12xgc2 = JSX_1kxb2["Element"];
+/**
+* Mirror of `renderCollectionModule` for Payload globals. Reads
+* `global.custom.path`, resolves it through the importMap, and renders
+* the resulting module with the supplied props.
+*
+* Globals don't have a `slug` field on docs (they're singletons), so
+* the only meaningful input beyond `importMap` is the resolved data
+* and the active locale.
+*
+* Returns `null` when:
+* - the global isn't registered in the host's Payload config
+*   (`globals.find(...)` returns undefined)
+* - `custom.path` is missing on the global
+* - the importMap doesn't have an entry for that path
+*
+* Throws in dev when `custom.path` is set but the importMap is
+* missing the entry — matches `renderCollectionModule`'s strictness
+* so the host gets a clear error in the console instead of a silent
+* layout break.
+*/
+declare function renderGlobalModule(globals: {
+	slug: string;
+	custom?: Record<string, any>;
+}[] | undefined, slug: string, importMap: ImportMap4, props?: Record<string, any>): Element_12xgc2 | null;
+import { DataFromGlobalSlug, SanitizedConfig as SanitizedConfig2 } from "payload";
+/**
+* Build an `unstable_cache`-wrapped getter for a Payload global.
+* Tag is `global_<slug>` (covers all locales); the lib's
+* `createRevalidateGlobalHook` fires both this tag and a per-locale
+* `global_<slug>_<locale>` so both single-slot and per-locale cache
+* strategies stay fresh after a save.
+*
+* Hosts that already had a hand-rolled `getCachedGlobal` (e.g. the
+* demo) can swap their import for this one without changing the
+* call sites — the shape matches.
+*
+* Usage:
+*
+*   import { getCachedGlobal } from '@justanarthur/payload-www/server'
+*   const header = await getCachedGlobal(configPromise, 'header', 1)()
+*/
+declare const getCachedGlobal: <G extends string>(config: Promise<SanitizedConfig2>, slug: G, depth?: number) => (() => Promise<DataFromGlobalSlug<G> | null>);
+/**
+* Type alias for the return shape — matches Payload's
+* `DataFromGlobalSlug<slug>` for typed access in the host.
+*/
+type CachedGlobal<G extends string> = DataFromGlobalSlug<G>;
+declare function buildHreflangAlternates<L extends string>({ siteUrl, locale, urlPrefix, storedSlug, queryAllLocaleSlugs, nested, homeSlug, defaultLocale, locales, localePrefix }: {
+	siteUrl: string;
+	locale: L;
+	urlPrefix: string;
+	storedSlug: string;
+	queryAllLocaleSlugs: (slug: string, locale: L) => Promise<Partial<Record<L, string>> | undefined>;
+	nested: boolean;
+	homeSlug: string;
+	defaultLocale: L;
+	locales: readonly L[];
+	/**
+	* Locale prefix mode — mirrors next-intl's `localePrefix` so each
+	* alternate URL matches the host's actual route shape:
+	*
+	* - `'always'`: every URL is prefixed with `/{locale}/…`
+	*   (e.g. `/en/about`, `/uk/about`). The default — preserves
+	*   the helper's prior behavior.
+	* - `'as-needed'`: the default locale renders without a prefix
+	*   (e.g. `/about`), other locales are prefixed (`/uk/about`).
+	*   Critical: callers that emit hreflang alongside a canonical
+	*   URL built with `as-needed` mode MUST pass this through,
+	*   otherwise the `en` and `x-default` alternates point to URLs
+	*   the host doesn't actually serve.
+	* - `'never'`: no locale prefix at all.
+	*/
+	localePrefix?: "always" | "as-needed" | "never";
+}): Promise<Record<string, string>>;
+declare function segmentsToStoredSlug(segments: string[] | string, nested?: boolean): string;
+declare function segmentsToUrlPath(segments: string[] | string, nested?: boolean): string;
+declare function storedSlugToSegments(storedSlug: string, nested?: boolean): string[] | string;
+declare function buildCanonicalUrl<L extends string>({ siteUrl, locale, urlPrefix, urlPath }: {
+	siteUrl: string;
+	locale: L;
+	urlPrefix: string;
+	urlPath: string;
+}): string;
+declare function getUrlPath(segments: string[] | string, nested: boolean, homeSlug: string): string;
+import { DataFromCollectionSlug as DataFromCollectionSlug2, DataFromGlobalSlug as DataFromGlobalSlug2, ImportMap as ImportMap5, SanitizedConfig as SanitizedConfig3 } from "payload";
+declare const queryDocBySlug: <S extends string>({ collectionSlug, slug, slugField, locale, draft, config }: {
+	collectionSlug: S;
+	slug: string;
+	slugField?: string;
+	locale: string;
+	draft?: boolean;
+	config: Promise<SanitizedConfig3>;
+}) => Promise<DataFromCollectionSlug2<S> | null>;
+declare const queryAllDocs: <S extends string>({ collectionSlug, slugField, locale, config }: {
+	collectionSlug: S;
+	slugField?: string;
+	locale: string;
+	config: Promise<SanitizedConfig3>;
+}) => Promise<DataFromCollectionSlug2<S>[]>;
+declare const queryAllLocaleSlugs2: <S extends string>({ collectionSlug, slug, slugField, locale, config }: {
+	collectionSlug: S;
+	slug: string;
+	slugField?: string;
+	locale: string;
+	config: Promise<SanitizedConfig3>;
+}) => Promise<Record<string, string> | undefined>;
+declare const queryGlobal: <G extends string>({ globalSlug, locale, depth, draft, config }: {
+	globalSlug: G;
+	locale: string;
+	depth?: number;
+	draft?: boolean;
+	config: Promise<SanitizedConfig3>;
+}) => Promise<DataFromGlobalSlug2<G> | null>;
+declare function getRenderModuleExports(exportName: string, collection: {
+	custom?: Record<string, unknown>;
+} | undefined, importMap: ImportMap5): unknown;
+import { FC } from "react";
+import { ImportMap as ImportMap6, SanitizedConfig as SanitizedConfig4 } from "payload";
+type RenderBlocksProps = {
+	blocks: Array<{
+		blockType: string;
+	} & Record<string, unknown>>;
+	blockProps?: Record<string, unknown>;
+	importMap: ImportMap6;
+	config: SanitizedConfig4;
+	locale: string;
+	searchParams?: Record<string, string | string[] | undefined>;
+};
+/**
+* Render a page's `blocks` array to React. Each block's render module
+* is resolved via Payload's generated importMap. The host registers
+* each block in the importMap with a key like `BlockCta#default` (use
+* `generateImportName('block', 'cta')` to build the key).
+*
+* Falls back gracefully: if a block's importMap path is missing or
+* the component is not registered, the block is skipped and a
+* `console.warn` is logged (in dev).
+*/
+declare const RenderBlocks: FC<RenderBlocksProps>;
+import { Payload } from "payload";
+type SeedPageInput = {
+	slug: string;
+	title: Record<string, string>;
+	meta?: Record<string, {
+		title?: string;
+		description?: string;
+	}>;
+	blocks?: Array<Record<string, unknown>>;
+	status?: "draft" | "published";
+	publishedAt?: string;
+};
+type SeedPostInput = {
+	slug: string;
+	title: Record<string, string>;
+	excerpt?: Record<string, string>;
+	content?: Record<string, unknown>;
+	status?: "draft" | "published";
+	publishedAt?: string;
+};
+type SeedUserInput = {
+	email: string;
+	password?: string;
+	name?: string;
+};
+type SeedCategoryInput = {
+	title: string;
+	slug?: string;
+};
+type CreateBaseSeedOptions = {
+	defaultLocale?: string;
+	locales?: string[];
+	users?: SeedUserInput[];
+	categories?: SeedCategoryInput[];
+	pages?: SeedPageInput[];
+	posts?: SeedPostInput[];
+	dryRun?: boolean;
+};
+type CreateBaseSeedResult = {
+	users: Array<{
+		id: string | number;
+		email: string;
+	}>;
+	categories: Array<{
+		id: string | number;
+		title: string;
+		slug: string;
+	}>;
+	pages: Array<{
+		id: string | number;
+		slug: string;
+		locale: string;
+	}>;
+	posts: Array<{
+		id: string | number;
+		slug: string;
+		locale: string;
+	}>;
+};
+/**
+* Idempotent seeder for the lib's collections. Re-running on the
+* same database is a no-op for users (matched by email) and
+* categories (matched by title); pages and posts are matched by
+* slug and re-created if missing.
+*
+* Pages and posts are created once per slug — localized values are
+* stored in a single doc per slug. Tests assert the alternate
+* resolution by querying `locale: 'all'`.
+*
+* Throws on:
+*   - any block slug in a Page's `layout` that doesn't exist on the
+*     Pages collection's `blocks` field
+*   - a block without a `blockType`
+*/
+declare function createBaseSeed(payload: Payload, options?: CreateBaseSeedOptions): Promise<CreateBaseSeedResult>;
+import { Payload as Payload2 } from "payload";
+type CreateTestPayloadOptions = {
+	/** Default blocks for the Pages collection. */
+	blocks?: any[];
+	/** Locale list. First entry is the default locale. */
+	locales?: readonly string[];
+	/** Database file path. Default: temp file. */
+	databaseFile?: string;
+	/** Run payload auto-migration before returning. Default: `true`. */
+	migrate?: boolean;
+	/**
+	* Strip `versions` from the Pages collection. Default: `false`.
+	* Set to `true` for integration tests that don't need versioning
+	* (avoids a payload@3.85 drizzle version-table build quirk).
+	*/
+	overridePagesVersions?: boolean;
+};
+type CreateTestPayloadResult = {
+	payload: Payload2;
+	databaseFile: string;
+	destroy: () => Promise<void>;
+};
+/**
+* Build a Payload instance backed by a temp SQLite database for
+* vitest integration tests. The lib's `createWWWConfig` is wired
+* with a single empty-block Pages collection; tests add more
+* collections via `configOverrides` if needed.
+*/
+declare function createTestPayload(options?: CreateTestPayloadOptions): Promise<CreateTestPayloadResult>;
+import { ImportMap as ImportMap7, SanitizedConfig as SanitizedConfig5 } from "payload";
+import { ReactElement as ReactElement2 } from "react";
+type CreateStaticPageExportsArgs = {
+	/**
+	* The `kind` discriminator to fetch from the `staticPages`
+	* collection. Default: `'not-found'`. The factory fetches the
+	* row where `kind === {kind}` and renders its `blocks` via
+	* `PagesPage` (the same component the catch-all dynamic route
+	* uses).
+	*/
+	kind?: string;
+	/**
+	* Payload config promise (same shape as `createCollectionPageExports`).
+	*/
+	config: Promise<SanitizedConfig5>;
+	/**
+	* Host's Payload importMap. Same purpose as the Pages factory.
+	* Default: `{}`.
+	*/
+	importMap?: ImportMap7;
+};
+/**
+* Build a static page's default — designed for Next.js
+* `not-found.tsx` / `error.tsx` (and similar) route files. Static
+* pages are addressed by a `kind` discriminator, not a slug, so
+* they don't need metadata, sitemap, or static-params plumbing.
+*
+* Per Next.js docs, not-found/error components receive **no
+* props**. The active locale is read via `getLocale()` from
+* `next-intl/server`, which reads from the request config
+* populated by middleware from the `[locale]` URL segment (the
+* host's `i18n/request.ts` handles invalid-locale fallback
+* before this returns).
+*
+*   // app/(frontend)/[locale]/not-found.tsx
+*   import configPromise from '@payload-config'
+*   import { createStaticPageExports } from '@justanarthur/payload-www/render-pages'
+*   import { importMap } from '@/app/(payload)/admin/importMap.js'
+*
+*   const { default: NotFound } = createStaticPageExports({
+*     config: configPromise,
+*     importMap,
+*   })
+*   NotFound
+*
+*   // app/(frontend)/[locale]/server-error.tsx
+*   const { default: ServerError } = createStaticPageExports({
+*     kind: 'server-error',
+*     config: configPromise,
+*     importMap,
+*   })
+*   ServerError
+*/
+declare function createStaticPageExports({ kind, config: configPromise, importMap: importMapArg }: CreateStaticPageExportsArgs): {
+	default: () => Promise<ReactElement2>;
+};
+import { CollectionSlug, PayloadRequest } from "payload";
+declare function generatePreviewPath({ collection, slug }: {
+	collection: CollectionSlug;
+	slug: string | null | undefined;
+	req?: PayloadRequest;
+}): string | null;
+export { storedSlugToSegments, segmentsToUrlPath, segmentsToStoredSlug, renderGlobalModule, renderCollectionModule, queryGlobal, queryDocBySlug, queryAllLocaleSlugs2 as queryAllLocaleSlugs, queryAllDocs, linkGroup, link, getUrlPath, getRenderModuleExports, getFromImportMap, getCachedGlobal, generatePreviewPath, generateImportName, createWWWConfig as default, createWWWConfig, createTestPayload, createStaticPagesCollection, createStaticPageExports, createRevalidatePageHooks, createRevalidateGlobalHook, createRevalidateCollectionHook, createPostsCollection, createPagesCollection, createHeaderGlobal, createFooterGlobal, createCollectionPageExports, createBaseSeed, buildOrganizationLd, buildHreflangAlternates, buildCanonicalUrl, buildBreadcrumbsLd, buildArticleLd, authenticatedOrPublished, authenticated, appearanceOptions, anyone, addCollectionsToSitemap, WWWInputConfig, WWWConfigOptions, WWWConfigApi, SeedUserInput, SeedPostInput, SeedPageInput, SeedCategoryInput, STATIC_PAGES_SLUG, RenderBlocksProps, RenderBlocks, PageExtendProps, POSTS_SLUG, PAGES_SLUG, MetadataOptions, LinkOptions, LinkAppearances, JsonLdOutput, JsonLdEntry, HOME_PAGE_SLUG, CreateTestPayloadResult, CreateTestPayloadOptions, CreateStaticPagesCollectionOptions, CreateStaticPageExportsArgs, CreateRevalidatePageHooksOptions, CreateRevalidateCollectionHookOptions, CreatePostsCollectionOptions, CreatePagesCollectionOptions, CreateHeaderGlobalOptions, CreateFooterGlobalOptions, CreateCollectionPageExportsDeps, CreateCollectionPageExportsArgs, CreateBaseSeedResult, CreateBaseSeedOptions, CachedGlobal, BreadcrumbItem, ArticleLdOptions };