@justanarthur/payload-www 0.3.5 → 1.2.0

package/dist/access.d.ts

@@ -3,9 +3,9 @@ declare const anyone: Access;
 declare const authenticated: Access;
 declare const authenticatedOrPublished: Access;
 import { Access as Access_wc6ft0 } from "payload";
-declare const _default: {
+declare const access: {
 	anyone: Access_wc6ft0;
 	authenticated: Access_wc6ft0;
 	authenticatedOrPublished: Access_wc6ft0;
 };
-export { _default as default, authenticatedOrPublished, authenticated, anyone };
+export { access as default, authenticatedOrPublished, authenticated, anyone };

package/dist/access.js

@@ -1,21 +1,6 @@
 
-var __defProp = Object.defineProperty;
-var __returnValue = (v) => v;
-function __exportSetter(name, newValue) {
-  this[name] = __returnValue.bind(null, newValue);
-}
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: __exportSetter.bind(all, name)
-    });
-};
-var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 
-// src/core/access/index.ts
+// src/collections/access/index.ts
 var anyone = () => true;
 var authenticated = ({ req: { user } }) => Boolean(user);
 var authenticatedOrPublished = ({ req: { user } }) => {
@@ -25,7 +10,8 @@ var authenticatedOrPublished = ({ req: { user } }) => {
 };
 
 // src/exports/access.ts
-var access_default = { anyone, authenticated, authenticatedOrPublished };
+var access = { anyone, authenticated, authenticatedOrPublished };
+var access_default = access;
 export {
   access_default as default,
   authenticatedOrPublished,

package/dist/blocks.d.ts

@@ -1,24 +1,19 @@
 import { FC } from "react";
-import { ImportMap, SanitizedConfig } from "payload";
+import { ImportMap as ImportMap2, SanitizedConfig } from "payload";
+import { ComponentType } from "react";
+type AsyncImportMapEntry<T = ComponentType> = T | (() => Promise<{
+	default: T;
+} | T>);
+type AsyncImportMap = Record<string, AsyncImportMapEntry>;
 type RenderBlocksProps = {
 	blocks: Array<{
 		blockType: string;
 	} & Record<string, unknown>>;
 	blockProps?: Record<string, unknown>;
-	importMap: ImportMap;
+	importMap: ImportMap2 | AsyncImportMap;
 	config: SanitizedConfig;
 	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>;
 export { RenderBlocks as default, RenderBlocksProps, RenderBlocks };

package/dist/blocks.js

@@ -1,63 +1,44 @@
 
-var __defProp = Object.defineProperty;
-var __returnValue = (v) => v;
-function __exportSetter(name, newValue) {
-  this[name] = __returnValue.bind(null, newValue);
-}
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: __exportSetter.bind(all, name)
-    });
-};
-var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 
-// src/core/utils/getFromImportMap.ts
+// src/render/getFromImportMap.ts
 function getFromImportMap(key, importMap) {
-  return importMap[key.includes("#") ? key : key + "#default"];
-}
-
-// src/core/utils/generateImportName.ts
-function generateImportName(type, slug) {
-  switch (type) {
-    case "block":
-      return `Block${slug.replace(/(^\w|-\w)/g, (m) => m.replace("-", "").toUpperCase())}#default`;
-    case "page":
-      return `Page${slug.replace(/(^\w|-\w)/g, (m) => m.replace("-", "").toUpperCase())}#default`;
-    default:
-      throw new Error(`Unknown type: ${type}`);
+  if (!key)
+    return;
+  const entry = importMap[key.includes("#") ? key : `${key}#default`];
+  if (entry == null)
+    return;
+  if (typeof entry === "function") {
+    return entry().then((mod) => {
+      if (typeof mod === "function")
+        return mod;
+      const modObj = mod;
+      return modObj.default ?? mod;
+    });
   }
+  return entry;
 }
 
+// package.json
+var name = "@justanarthur/payload-www";
+
 // src/render/blocks/renderBlocks.tsx
 import { jsx, Fragment } from "react/jsx-runtime";
-var RenderBlocks = ({
-  blocks,
-  blockProps,
-  config,
-  importMap,
-  locale,
-  searchParams
-}) => {
-  if (!blocks || !Array.isArray(blocks) || blocks.length === 0) {
-    console.log("[WWW] render/blocks:RenderBlocks no blocks (locale=", locale, ")");
+var DEFAULT_BLOCK_PATH_PREFIX = "@/components/blocks";
+var RenderBlocks = async ({ blocks, blockProps, config, importMap, locale, searchParams }) => {
+  if (!blocks || !Array.isArray(blocks) || blocks.length === 0)
     return null;
-  }
-  console.log("[WWW] render/blocks:RenderBlocks rendering count=", blocks.length, "locale=", locale);
   const rendered = [];
   for (let i = 0;i < blocks.length; i++) {
     const block = blocks[i];
     const { blockType } = block;
-    const importMapPath = config.admin?.dependencies?.[blockType]?.path ?? generateImportName("block", blockType);
-    const Block = getFromImportMap(importMapPath, importMap);
+    const blockConfig = (config.blocks ?? []).find((b) => b.slug === blockType);
+    const customPath = blockConfig?.custom?.[name]?.path;
+    const importMapPath = (typeof customPath === "string" ? customPath : null) ?? `${DEFAULT_BLOCK_PATH_PREFIX}/${blockType}`;
+    const Block = await getFromImportMap(importMapPath, importMap);
     if (!Block) {
       console.warn(`[WWW] render/blocks:RenderBlocks no block for type=${blockType} importMapPath=${importMapPath} (locale=${locale})`);
       continue;
     }
-    console.log("[WWW] render/blocks:RenderBlocks [", i, "] blockType=", blockType, "importMapPath=", importMapPath);
     rendered.push(/* @__PURE__ */ jsx(Block, {
       index: i,
       ...blockProps,

package/dist/cli.js

@@ -0,0 +1,201 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/cli/index.ts
+import { register } from "tsx/esm/api";
+import path from "node:path";
+import { existsSync } from "node:fs";
+import { pathToFileURL } from "node:url";
+
+// package.json
+var name = "@justanarthur/payload-www";
+
+// src/cli/generateAsyncImportmap.ts
+function getCustomPath(custom, pkg) {
+  const v = custom?.[pkg]?.path;
+  return typeof v === "string" ? v : undefined;
+}
+function splitKey(key) {
+  const hashIdx = key.indexOf("#");
+  if (hashIdx >= 0) {
+    return {
+      filePath: key.slice(0, hashIdx),
+      exportName: key.slice(hashIdx + 1) || "default",
+      fullKey: key
+    };
+  }
+  return {
+    filePath: key,
+    exportName: "default",
+    fullKey: `${key}#default`
+  };
+}
+function defaultBlockPath(slug) {
+  return `@/components/blocks/${slug}#default`;
+}
+async function generateAsyncImportmap(config, options) {
+  const pkg = options.packageName ?? name;
+  const blocks = config.blocks ?? [] ?? [];
+  const collections = config.collections ?? [] ?? [];
+  const globals = config.globals ?? [] ?? [];
+  const keys = new Set;
+  for (const block of blocks) {
+    if (!block.slug)
+      continue;
+    const explicit = getCustomPath(block.custom, pkg);
+    const key = explicit ?? defaultBlockPath(block.slug);
+    keys.add(key);
+  }
+  for (const item of [...collections, ...globals]) {
+    const explicit = getCustomPath(item.custom, pkg);
+    if (explicit)
+      keys.add(explicit);
+  }
+  const sortedKeys = [...keys].sort();
+  const lines = [];
+  lines.push("// This file is generated by `payload-www generate:async-importmap`.");
+  lines.push("// Do not edit by hand — re-run the generator after Payload config changes.");
+  lines.push("");
+  lines.push("/** @type import('payload').ImportMap */");
+  lines.push("export const asyncImportMap = {");
+  for (const key of sortedKeys) {
+    const { filePath, exportName, fullKey } = splitKey(key);
+    const jsonKey = JSON.stringify(fullKey);
+    lines.push(`  ${jsonKey}: () => import(${JSON.stringify(filePath)}).then((m) => ({ default: m.${exportName} })),`);
+  }
+  lines.push("}");
+  lines.push("");
+  const output = lines.join(`
+`);
+  const { writeFile, mkdir } = await import("node:fs/promises");
+  const { dirname } = await import("node:path");
+  await mkdir(dirname(options.output), { recursive: true });
+  await writeFile(options.output, output, "utf-8");
+  return {
+    entries: sortedKeys.length,
+    output: options.output
+  };
+}
+
+// src/cli/index.ts
+register();
+function printHelp() {
+  console.log(`payload-www generate:async-importmap
+
+Generate an async-importMap.ts containing only the render-path dependencies
+(blocks + collection/global renderers) used by the public render path.
+
+Usage:
+  payload-www generate:async-importmap --config-path <path> --output <path>
+
+Options:
+  --config-path <path>   Path to the Payload config file (TS or JS).
+                         Resolved relative to the current working directory.
+  --output <path>        Output file path. Created if missing.
+  --package-name <name>  Custom-package key for the render-dependency lookup.
+                         Defaults to "@justanarthur/payload-www".
+  --help, -h             Show this help.
+
+Example:
+  payload-www generate:async-importmap \\
+    --config-path apps/www/payload.config.ts \\
+    --output apps/www/app/\\(payload\\)/admin/asyncImportMap.ts
+`);
+}
+function parseArgs(argv) {
+  const args = {
+    configPath: "",
+    output: "",
+    help: false
+  };
+  for (let i = 0;i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--help" || a === "-h") {
+      args.help = true;
+      continue;
+    }
+    if (a === "--config-path") {
+      args.configPath = argv[++i] ?? "";
+      continue;
+    }
+    if (a === "--output") {
+      args.output = argv[++i] ?? "";
+      continue;
+    }
+    if (a === "--package-name") {
+      args.packageName = argv[++i] ?? "";
+      continue;
+    }
+    if (a?.startsWith("--config-path=")) {
+      args.configPath = a.slice("--config-path=".length);
+      continue;
+    }
+    if (a?.startsWith("--output=")) {
+      args.output = a.slice("--output=".length);
+      continue;
+    }
+    if (a?.startsWith("--package-name=")) {
+      args.packageName = a.slice("--package-name=".length);
+      continue;
+    }
+  }
+  return args;
+}
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.help) {
+    printHelp();
+    process.exit(0);
+  }
+  if (!args.configPath || !args.output) {
+    console.error(`[payload-www] --config-path and --output are required.
+`);
+    printHelp();
+    process.exit(1);
+  }
+  const cwd = process.cwd();
+  const absoluteConfigPath = path.isAbsolute(args.configPath) ? args.configPath : path.resolve(cwd, args.configPath);
+  if (!existsSync(absoluteConfigPath)) {
+    console.error(`[payload-www] config file not found: ${absoluteConfigPath}`);
+    process.exit(1);
+  }
+  let configModule;
+  try {
+    configModule = await import(pathToFileURL(absoluteConfigPath).href);
+  } catch (err) {
+    console.error(`[payload-www] failed to load config at ${absoluteConfigPath}:`);
+    console.error(err);
+    process.exit(1);
+  }
+  let config = configModule.default ?? configModule;
+  config = await config;
+  if (!config || typeof config !== "object") {
+    console.error("[payload-www] loaded config is empty or not an object.");
+    process.exit(1);
+  }
+  if (process.env.PAYLOAD_WWW_DEBUG === "1") {
+    const { writeFileSync } = await import("node:fs");
+    writeFileSync("/tmp/payload-config-dump.json", JSON.stringify(config, (k, v) => typeof v === "function" ? "[function]" : v, 2).slice(0, 200000));
+    const cfg = config;
+    console.error("[payload-www DEBUG] blocks:", cfg.blocks?.length ?? 0);
+    console.error("[payload-www DEBUG] collections:", cfg.collections?.length ?? 0);
+    console.error("[payload-www DEBUG] globals:", cfg.globals?.length ?? 0);
+    console.error("[payload-www DEBUG] keys:", Object.keys(config).slice(0, 30).join(","));
+    const firstBlock = cfg.blocks?.[0] ?? null;
+    if (firstBlock) {
+      console.error("[payload-www DEBUG] first block slug:", firstBlock.slug);
+      console.error("[payload-www DEBUG] first block custom:", JSON.stringify(firstBlock.custom));
+    }
+  }
+  const result = await generateAsyncImportmap(config, {
+    output: path.isAbsolute(args.output) ? args.output : path.resolve(cwd, args.output),
+    ...args.packageName ? { packageName: args.packageName } : {}
+  });
+  console.log(`[payload-www] wrote ${result.entries} entries to ${result.output}`);
+}
+main().catch((err) => {
+  console.error("[payload-www] unhandled error:");
+  console.error(err);
+  process.exit(1);
+});

package/dist/collections.d.ts

@@ -1,229 +1,37 @@
-import { Block, CollectionConfig } 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";
-};
-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"];
-	/**
-	* Enable nested (hierarchical) slugs. When `true`, the slug field
-	* additionally accepts the `_` nesting divider (so `about_us`
-	* renders at `/about/us`) and the admin description documents the
-	* convention. Pair with `createCollectionPageExports({ nested: true })`
-	* on the matching route. Default: `false` (flat, hyphen-only slugs).
-	*/
-	nested?: boolean;
-};
-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;
+import { CollectionConfig, Field, GlobalConfig } from "payload";
+type CreateWWWCollectionArgs<IsGlobalConfig extends boolean> = {
+	slug: string;
+	renderPath: string;
+	isGlobalConfig?: IsGlobalConfig;
+	isDraft?: boolean;
 };
-/**
-* 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";
-declare const STATIC_PAGES_SLUG = "staticPages";
-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 function createWWWCollectionGlobal<
+	IsGlobalConfig extends boolean = false,
+	Config = IsGlobalConfig extends true ? GlobalConfig : CollectionConfig
+>(fields: Field[], { slug: collectionSlug, renderPath, isGlobalConfig, isDraft }: CreateWWWCollectionArgs<IsGlobalConfig>): Config;
+import { CollectionAfterChangeHook, CollectionAfterDeleteHook, GlobalAfterChangeHook } from "payload";
+declare function createRevalidateCollectionGlobalHook(): {
+	afterChange: (CollectionAfterChangeHook & CollectionAfterDeleteHook) | GlobalAfterChangeHook;
+	afterDelete: (CollectionAfterChangeHook & CollectionAfterDeleteHook) | GlobalAfterChangeHook;
 };
-declare const createStaticPagesCollection: (blocks: Block2[]) => CollectionConfig3;
-import { Field, 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[];
-	/**
-	* Extra fields appended to each `navColumn` link — e.g. a
-	* `description` text field or a `navHover` group for a mega-menu.
-	* Lets hosts enrich the column-link schema without redefining the
-	* whole nav.
-	*/
-	navColumnLinkFields?: Field[];
-	/**
-	* Extra fields appended to each top-level `navItem` link.
-	*/
-	navItemLinkFields?: Field[];
-};
-/**
-* 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 { Field as Field2, 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[];
-	/**
-	* Extra fields appended to each `navColumn` link — e.g. a
-	* `description` text field. Lets hosts enrich the column-link
-	* schema without redefining the whole nav.
-	*/
-	navColumnLinkFields?: Field2[];
-	/**
-	* Extra fields appended to each top-level `navItem` link.
-	*/
-	navItemLinkFields?: Field2[];
+type CollectionGlobalLocaleIdentifiersArgs = ({
+	collectionSlug: string;
+	slug: string;
+} | {
+	globalSlug: string;
+}) & {
+	locale: 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;
-import { CollectionSlug, PayloadRequest } from "payload";
-declare function generatePreviewPath({ collection, slug }: {
-	collection: CollectionSlug;
-	slug: string | null | undefined;
-	req?: PayloadRequest;
-}): string | null;
-import { Block as Block_129qi5 } from "payload";
-import { CollectionConfig as CollectionConfig_j7kwbk } from "payload";
-import { GlobalConfig as GlobalConfig_fuin17 } from "payload";
-declare const _default: {
-	createPagesCollection: (blocks: Block_129qi5[], options?: Omit<CreatePagesCollectionOptions, "blocks">) => CollectionConfig_j7kwbk;
-	createPostsCollection: (options?: CreatePostsCollectionOptions) => CollectionConfig_j7kwbk;
-	createStaticPagesCollection: (blocks: Block_129qi5[]) => CollectionConfig_j7kwbk;
-	createHeaderGlobal: (options?: CreateHeaderGlobalOptions) => GlobalConfig_fuin17;
-	createFooterGlobal: (options?: CreateFooterGlobalOptions) => GlobalConfig_fuin17;
-	generatePreviewPath: typeof generatePreviewPath;
-	HOME_PAGE_SLUG: string;
-	PAGES_SLUG: string;
-	POSTS_SLUG: string;
-	STATIC_PAGES_SLUG: string;
+declare function createCollectionCacheKey(args: CollectionGlobalLocaleIdentifiersArgs): string;
+import { SanitizedConfig } from "payload";
+import { JsonObject as JsonObject_wrdbbt } from "payload";
+declare function queryDoc(args: CollectionGlobalLocaleIdentifiersArgs, { config: configPromise }: {
+	config: Promise<SanitizedConfig>;
+}): Promise<JsonObject_wrdbbt | null>;
+declare const collections: {
+	createWWWCollectionGlobal: typeof createWWWCollectionGlobal;
+	createRevalidateCollectionGlobalHook: typeof createRevalidateCollectionGlobalHook;
+	createCollectionCacheKey: typeof createCollectionCacheKey;
+	queryDoc: typeof queryDoc;
 };
-export { generatePreviewPath, _default as default, createStaticPagesCollection, createPostsCollection, createPagesCollection, createHeaderGlobal, createFooterGlobal, STATIC_PAGES_SLUG, POSTS_SLUG, PAGES_SLUG, HOME_PAGE_SLUG, CreateStaticPagesCollectionOptions, CreatePostsCollectionOptions, CreatePagesCollectionOptions, CreateHeaderGlobalOptions, CreateFooterGlobalOptions };
+export { queryDoc, collections as default, createWWWCollectionGlobal, createRevalidateCollectionGlobalHook, createCollectionCacheKey };