@capacms/sdk 1.0.0-next.0 → 1.0.0-next.10

package/dist/nextjs/index.d.ts

@@ -1,20 +1,55 @@
-import { type CapaNextClient, type CapaNextConfig, type PagesResource, type PreviewClaim } from "../next";
+import { gql, LAYOUT_PAGE, type CapaDocumentResult, type CapaDocuments, type CapaDocumentVariables, type CapaNextClient, type CapaNextConfig, type GraphQLCallOptions, type GraphQLResult, type NotARecordedDocument, type PagesResource, type PreviewClaim, type TypedDocument, type UntypedQuery, type VariablesThenOptions } from "../next";
 export interface CacheOptions {
     tags?: string[];
     revalidate?: number | false;
 }
 /** Add Next.js fetch-cache options without importing `next/*`. */
 export declare function withCache(fetchImpl: typeof fetch, options: CacheOptions): typeof fetch;
+/**
+ * The Next.js cache tag for every read of a model, by its namespace. A GraphQL
+ * query names its models by namespace (`articles`), not by id, so this is the
+ * tag a GraphQL read is cached under, and `revalidateFromWebhook` revalidates
+ * it when an entry of that model changes.
+ */
+export declare function modelTag(namespace: string): string;
+/**
+ * The tag `graphql()` keeps a read under when it gives a `revalidate` and no
+ * `tags`, and that `revalidateFromWebhook` revalidates on every content
+ * change: such a page is never stale after a publish, at the price of
+ * refreshing on any publish. Name the models it reads with
+ * `tagsFor({ namespace })` to refresh it only when one of those changes. A
+ * read with neither `tags` nor `revalidate` is not kept at all.
+ */
+export declare const GRAPHQL_TAG = "capa:graphql";
+/**
+ * The tag `tagsFor({ namespace })` adds beside its model tags, and that
+ * `revalidateFromWebhook` revalidates on a media event: a GraphQL read shows
+ * a file's URL and alt text whichever models it names, so editing a file in
+ * the media library refreshes it.
+ */
+export declare const MEDIA_TAG = "capa:media";
+/**
+ * Next.js cache tags for a read. `model`, `entry`, `key` and `tenant` are the
+ * API's surrogate keys (`m:`, `e:`, `k:`, `t:`), by id; `namespace` is one
+ * `capa:model:<namespace>` tag per model a GraphQL query reads, which
+ * `capa-codegen --graphql` lists as `<Name>Models`, and `MEDIA_TAG`, since
+ * the query may show a file from the media library. Each pairs with
+ * `revalidateFromWebhook`.
+ */
 export declare function tagsFor(input: {
     model?: string;
     entry?: string;
     key?: string;
     tenant?: string;
+    namespace?: string | readonly string[];
 }): string[];
 export interface WebhookPayload {
+    type?: unknown;
     data?: {
         instanceId?: unknown;
         modelId?: unknown;
+        modelNamespace?: unknown;
+        namespace?: unknown;
         [key: string]: unknown;
     };
     instanceId?: unknown;
@@ -22,17 +57,34 @@ export interface WebhookPayload {
     modelId?: unknown;
     [key: string]: unknown;
 }
-/** Revalidate the concrete entry and model identities carried by a webhook. */
+/**
+ * Revalidate every tag a webhook's entry and model can be cached under: the
+ * entry (`e:`), the model by id (`m:`) and by namespace (`capa:model:`, the
+ * tag a GraphQL read uses). The namespace is `data.modelNamespace` on
+ * `instance.published`, `instance.unpublished` and `model.published`, and
+ * `data.namespace` on the other events (docs/WEBHOOKS.md). Any of those, and
+ * a `media.` event, also revalidates `GRAPHQL_TAG`, the tag of a `graphql()`
+ * read that named no tags. A `media.` event (a file's alt text, name or
+ * visibility changed, or the file went) revalidates the file's own key
+ * (`f:<fileId>`, as REST's `Surrogate-Key` names it) and `MEDIA_TAG`, which
+ * every read tagged by namespace carries, since it may show that file.
+ */
 export declare function revalidateFromWebhook(input: {
     payload: WebhookPayload;
     revalidateTag: (tag: string) => void | Promise<void>;
 }): Promise<string[]>;
-/** Select a client using server-only draft state supplied by the caller. */
-export declare function draftClient(input: {
+/**
+ * Select a client using server-only draft state supplied by the caller. Pass
+ * codegen's `CapaQuery` to type the builder, as with `createClient`:
+ * `draftClient<CapaQuery>({ ... })`. `production` may hold the legacy key a
+ * site already has; `draft` needs a `cap_` key, and a legacy one throws a
+ * `TypeError` when draft mode selects it.
+ */
+export declare function draftClient<Q = UntypedQuery>(input: {
     production: CapaNextConfig;
     draft: CapaNextConfig;
     isDraft: () => boolean | Promise<boolean>;
-}): Promise<CapaNextClient>;
+}): Promise<CapaNextClient<Q>>;
 export declare function routeOf(file: string): string;
 /**
  * Verify a preview token from a Next route handler.
@@ -50,4 +102,431 @@ export declare function preview(token: string, client: CapaNextClient): Promise<
  * this and never hold the whole client.
  */
 export declare function pagesFor(client: CapaNextClient): PagesResource;
+export { gql, LAYOUT_PAGE };
 export type { PreviewClaim };
+export { capaImageLoader, createCapaImageLoader } from "./image-loader";
+export type { CapaImageLoader, CapaImageLoaderOptions, CapaImageLoaderProps } from "./image-loader";
+/**
+ * The query parameter that turns edit mode on for one request without draft
+ * content: `?capa-edit=<token>`, where the token is a Capa preview token. The
+ * Capa editor's Published view sends it so the published page is still
+ * clickable. It never switches the site to draft data.
+ */
+export declare const EDIT_PARAM = "capa-edit";
+/** The query parameter a Capa preview link carries: `?capa-preview=<token>`. */
+export declare const PREVIEW_PARAM = "capa-preview";
+/** The query parameter of the editor's Published view: `?capa-view=published`. */
+export declare const VIEW_PARAM = "capa-view";
+/**
+ * The request header `resolveEditRequest` sets once a `capa-edit` token has
+ * been verified, for `editMode()` to read. Any copy a browser sent is removed
+ * first, so it cannot be forged from outside.
+ */
+export declare const EDIT_HEADER = "x-capa-edit";
+/** The cookie Next's `draftMode().enable()` sets. */
+export declare const DRAFT_COOKIE = "__prerender_bypass";
+/** What every edit-mode response must send: never cached, never shared. */
+export declare const EDIT_CACHE_CONTROL = "private, no-store";
+interface HeaderReader {
+    get(name: string): string | null;
+}
+/**
+ * Whether this request renders in edit mode: Next draft mode is on, or the
+ * request carried a verified `capa-edit` token (see `resolveEditRequest`).
+ *
+ * Pass Next's own functions; this package imports nothing from `next`:
+ *
+ *   import { draftMode, headers } from "next/headers";
+ *   const edit = await editMode({ draftMode, headers });
+ *   const client = createClient({ ...config, editMode: edit });
+ *
+ * A client built with `editMode: edit` marks what it reads, and `capaAttrs`
+ * then tags those entries and only those.
+ */
+export declare function editMode(input: {
+    draftMode: () => {
+        isEnabled: boolean;
+    } | Promise<{
+        isEnabled: boolean;
+    }>;
+    headers: () => HeaderReader | Promise<HeaderReader>;
+}): Promise<boolean>;
+export interface EditRequest {
+    /** True when the page must render in edit mode. */
+    edit: boolean;
+    /** True when a `capa-edit` token was presented and Capa accepted it. */
+    verified: boolean;
+    /**
+     * The request headers to forward: `x-capa-edit` removed, then set to `1`
+     * when the token verified. Hand them to `NextResponse.next({ request: { headers } })`.
+     */
+    headers: Headers;
+    /** `EDIT_CACHE_CONTROL` in edit mode, otherwise null. Set it on the response. */
+    cacheControl: string | null;
+    /** `DRAFT_ROBOTS_TAG` in edit mode, otherwise null. Set it on the response as `X-Robots-Tag`. */
+    robotsTag: string | null;
+}
+/**
+ * The middleware half of edit mode.
+ *
+ *   export async function middleware(request: NextRequest) {
+ *     const edit = await resolveEditRequest(request, publishedClient());
+ *     const response = NextResponse.next({ request: { headers: edit.headers } });
+ *     if (edit.cacheControl) response.headers.set("Cache-Control", edit.cacheControl);
+ *     if (edit.robotsTag) response.headers.set("X-Robots-Tag", edit.robotsTag);
+ *     return response;
+ *   }
+ *
+ * The token is checked with Capa (`client.preview`), exactly as a preview link
+ * is: the site never holds the signing key. A bad, expired or unverifiable
+ * token means not in edit mode; it never throws, because a broken edit link
+ * must still render the public page.
+ */
+export declare function resolveEditRequest(request: {
+    url: string | URL;
+    headers: Headers;
+    cookies?: {
+        has(name: string): boolean;
+    };
+}, client: Pick<CapaNextClient, "preview">): Promise<EditRequest>;
+/**
+ * Where the env-driven helpers read their settings (M6): the one pair of
+ * names the whole product uses (the MCP server, `capa-codegen`, `capa
+ * persist`, every curl example in the API docs).
+ */
+export declare const CAPA_ENV: {
+    readonly baseUrl: "CAPA_API_URL";
+    readonly apiKey: "CAPA_KEY";
+    readonly draftKey: "CAPA_DRAFT_KEY";
+    readonly version: "CAPA_API_VERSION";
+};
+/** Older names that still work, read only when the name above is unset. */
+export declare const CAPA_ENV_ALIASES: Readonly<Record<string, string>>;
+export declare const DEFAULT_API_VERSION = "2026-10-01";
+type DraftModeFn = () => {
+    isEnabled: boolean;
+    enable?: () => void;
+    disable?: () => void;
+} | Promise<{
+    isEnabled: boolean;
+    enable?: () => void;
+    disable?: () => void;
+}>;
+/**
+ * The published-key client from env: what verifying a token needs. `overrides`
+ * win over env, and pass codegen's `CapaQuery` to type the builder:
+ * `getPublishedClient<CapaQuery>()`.
+ */
+export declare function getPublishedClient<Q = UntypedQuery>(overrides?: Partial<CapaNextConfig>): CapaNextClient<Q>;
+/**
+ * The client for this request, from env: the draft key under draft mode,
+ * otherwise the published key, and `editMode` worked out for you.
+ *
+ *   import { draftMode, headers } from "next/headers";
+ *   const capa = await getCapaClient<CapaQuery>({ draftMode, headers });
+ *   const { data } = await capa.graphql.query(selection, { tags: tagsFor({ namespace: "articles" }) });
+ *
+ * `CapaQuery` (from `capa-codegen --graphql`) types the builder, as with
+ * `createClient`; leave it out for an untyped client. `config` wins over env.
+ *
+ * Its REST reads are sent as `createClient` sends them, which Next does not
+ * keep. Its GraphQL reads, a document or the builder, are sent the same way
+ * unless a call gives `tags` or `revalidate`, so a publish shows up on both
+ * alike. Given either, a read is kept in Next's data cache exactly as
+ * `graphql()` keeps it: a published read with no errors, never a draft or an
+ * edit-mode page.
+ */
+export declare function getCapaClient<Q = UntypedQuery>(input: {
+    draftMode: DraftModeFn;
+    headers: () => HeaderReader | Promise<HeaderReader>;
+    config?: Partial<CapaNextConfig>;
+    /** Next's `unstable_cache`, as `graphql()` takes it. Leave it out: Next's own is loaded. */
+    unstable_cache?: UnstableCache;
+}): Promise<CapaNextClient<Q, NextCacheOptions>>;
+/** Where a GraphQL read in Next keeps its answer: Next's data cache, as `graphql()` and `getCapaClient` keep it. */
+export interface NextCacheOptions extends GraphQLCallOptions {
+    /**
+     * Next.js cache tags to keep this read under. `tagsFor({ namespace:
+     * <Name>Models })`, with the list `capa-codegen --graphql` writes beside
+     * each document, tags it with every model the query reads, which
+     * `revalidateFromWebhook` revalidates on a publish. Given a `revalidate`
+     * and no tags, the read is kept under `GRAPHQL_TAG`, which every publish
+     * revalidates. Given neither, the read is not kept: it is sent as a REST
+     * read is, on every render.
+     */
+    tags?: string[];
+    /** Seconds to cache, `false` to cache until a tag is revalidated, or 0 not to cache. */
+    revalidate?: number | false;
+}
+export interface NextGraphQLOptions extends NextCacheOptions {
+    /**
+     * Next's `draftMode` and `headers`, to work out draft and edit mode as
+     * `getCapaClient` does: drafts under draft mode, and in edit mode every
+     * entry the query reads marked for `capaAttrs`.
+     */
+    draftMode?: DraftModeFn;
+    headers?: () => HeaderReader | Promise<HeaderReader>;
+    /**
+     * Read drafts with `CAPA_DRAFT_KEY`, uncached. Worked out from `draftMode`
+     * when that is passed; set it to decide yourself.
+     */
+    draft?: boolean;
+    /** Overrides for the env-derived client (base URL, key, version, edit mode, fetch). Each one given is not read from env. */
+    config?: Partial<CapaNextConfig>;
+    /**
+     * Next's `unstable_cache`, from `next/cache`. Leave it out: `graphql()`
+     * loads Next's own. A published read given `tags` or a `revalidate` is kept
+     * in Next's data cache only when it answered with no `errors`, under `tags`
+     * for `revalidate` seconds, or with no `revalidate` until one of its tags is
+     * revalidated. Next's fetch
+     * cache is not used for it: that cache keeps any 200, and a GraphQL error
+     * is a 200 (a root field that timed out), and in Next 15 it keeps nothing
+     * without a `revalidate`, tags or not. Pass it only to supply another.
+     */
+    unstable_cache?: UnstableCache;
+}
+/**
+ * Next's `unstable_cache` (`import { unstable_cache } from "next/cache"`),
+ * typed here so this package never imports `next/*`.
+ */
+export type UnstableCache = <T extends (...args: any[]) => Promise<any>>(cb: T, keyParts?: string[], options?: {
+    revalidate?: number | false;
+    tags?: string[];
+}) => T;
+/**
+ * GraphQL in a server component, one line, from env:
+ *
+ *   import { draftMode, headers } from "next/headers";
+ *   import { graphql, tagsFor } from "@capacms/sdk/nextjs";
+ *   import { LatestModels } from "./capa-graphql";
+ *   const LATEST = `#graphql
+ *     query Latest($first: Int) { articles(first: $first) { nodes { id model title } } }
+ *   `;
+ *   const { data } = await graphql(LATEST, { first: 5 }, { draftMode, headers, tags: tagsFor({ namespace: LatestModels }) });
+ *
+ * Once `capa-codegen --graphql` has seen the literal, `data` and the
+ * variables are typed from it, as they are for a `<Name>Document` it writes,
+ * and `LatestModels` lists the models it reads.
+ *
+ * With no `tags` and no `revalidate` a read is sent as the REST reads are,
+ * and Next keeps nothing: the page shows a publish on its next render, as a
+ * page reading by REST does. Given either, a published read is kept in Next's
+ * data cache (`unstable_cache`) when it answered with no errors: under `tags`,
+ * for `revalidate` seconds, or with no `revalidate` until
+ * `revalidateFromWebhook` revalidates one of its tags on a publish. It goes
+ * as a GET, which the CDN and the API also cache for the published key; a
+ * document too long for a GET URL goes as a POST, which only Next's data
+ * cache keeps. Under draft mode the read uses `CAPA_DRAFT_KEY`, a
+ * `cap_` key, and bypasses the cache (the API answers a development key's GET
+ * `no-store`), the same split `getCapaClient` makes for REST, and in edit mode
+ * each entry that selects `id` and `model` is marked for `capaAttrs`, uncached.
+ * Outside a Next request (a script, a test) the read is simply sent.
+ *
+ * `persisted: true` sends only the hash, and pays off once the documents are
+ * stored with `capa persist`, which takes a development key: a production
+ * key never stores one. Until then a
+ * hash misses, and the client remembers the miss for five minutes and sends
+ * the document by POST meanwhile, so it costs one extra GET per five minutes.
+ */
+export declare function graphql<D extends keyof CapaDocuments>(document: D, ...rest: VariablesThenOptions<CapaDocumentVariables<D>, NextGraphQLOptions>): Promise<GraphQLResult<CapaDocumentResult<D>>>;
+export declare function graphql<TData = Record<string, unknown>, TVariables = Record<string, unknown>, D extends string = string>(document: NotARecordedDocument<D, TypedDocument<TData, TVariables> | D>, ...rest: VariablesThenOptions<TVariables, NextGraphQLOptions>): Promise<GraphQLResult<TData>>;
+/** Only a path on this site: never `//elsewhere.example` or a full URL. */
+export declare function safeSitePath(value: string | null | undefined): string;
+/** The Capa admin's origin: what frames a draft in the editor, unless a site names another. */
+export declare const CAPA_ADMIN_ORIGIN = "https://app.capacms.com";
+/** `X-Robots-Tag` on every draft and edit-mode response: a draft is never indexed, nor its links followed. */
+export declare const DRAFT_ROBOTS_TAG = "noindex, nofollow";
+/** How long the draft cookie lasts, in seconds: one hour, as a preview token does. */
+export declare const DRAFT_COOKIE_MAX_AGE = 3600;
+/**
+ * `frame-ancestors 'self' <origins>`, the CSP directive that lets the Capa
+ * editor frame a draft and nothing else frame it. Each origin is a scheme and
+ * a host, with a port when it has one, and is written as the URL parser
+ * normalises it, so no `;` or quote can reach the policy. Anything else, a
+ * path or a query included, throws a `TypeError`.
+ */
+export declare function frameAncestors(adminOrigins?: readonly string[]): string;
+/**
+ * The headers every draft response carries: `X-Robots-Tag: noindex, nofollow`,
+ * and `Content-Security-Policy: frame-ancestors 'self' https://app.capacms.com`
+ * (or the `adminOrigins` given). Throws for an origin that is not one.
+ */
+export declare function draftHeaders(options?: {
+    adminOrigins?: readonly string[];
+}): Record<string, string>;
+/** One rule of `next.config`'s `headers()`, in the shape Next takes. */
+export interface NextHeaderRule {
+    source: string;
+    has: Array<{
+        type: "cookie" | "query";
+        key: string;
+    }>;
+    headers: Array<{
+        key: string;
+        value: string;
+    }>;
+}
+/**
+ * Rules for `next.config`'s `headers()` that send `draftHeaders` on draft
+ * responses only:
+ *
+ *   // next.config.mjs
+ *   import { capaHeaders } from "@capacms/sdk/nextjs";
+ *   export default { async headers() { return [...capaHeaders()]; } };
+ *
+ * A rule matches a request carrying the draft cookie, or a `capa-preview`,
+ * `capa-edit` or `capa-view` query. A visitor's request carries none of
+ * them, so its response, cached or not, is exactly what it was. Next checks
+ * the cookie by name, not by value, so a forged cookie only adds these
+ * headers to the forger's own response.
+ *
+ * A site that sends its own `frame-ancestors` or `X-Frame-Options` must leave
+ * them off draft responses (`missing: [{ type: "cookie", key: DRAFT_COOKIE }]`
+ * on its rule): a browser applies every CSP it is sent, so the strictest wins.
+ */
+export declare function capaHeaders(options?: {
+    adminOrigins?: readonly string[];
+}): NextHeaderRule[];
+/** The part of Next's `cookies()` store (`next/headers`) the draft-cookie helpers use. */
+export interface DraftCookieJar {
+    get(name: string): {
+        value: string;
+    } | undefined;
+    set(cookie: {
+        name: string;
+        value: string;
+        path: string;
+        httpOnly: boolean;
+        secure: boolean;
+        sameSite: "none";
+        partitioned: boolean;
+        maxAge?: number;
+        expires?: Date;
+    }): unknown;
+}
+/** Next's `cookies` from `next/headers`, or anything shaped like it. */
+export type CookiesFn = () => DraftCookieJar | Promise<DraftCookieJar>;
+/**
+ * Re-set the cookie `draftMode().enable()` just set, so the Capa editor can
+ * use it: `HttpOnly; Secure; SameSite=None; Partitioned; Path=/` and
+ * `Max-Age` one hour (`maxAge` seconds). Next sets it with no `Max-Age`, so
+ * it unlocks every draft on the site until the browser closes, and without
+ * `Partitioned`, which Safari 26.2 and later need to send a cookie into a
+ * cross-site frame. Call it after `enable()`, in the same route handler.
+ * Resolves false, and sets nothing, when there is no draft cookie to re-set.
+ */
+export declare function frameDraftCookie(cookies: CookiesFn, options?: {
+    maxAge?: number;
+}): Promise<boolean>;
+/**
+ * Delete the draft cookie `frameDraftCookie` set. A partitioned cookie is
+ * deleted only by a `Set-Cookie` that is partitioned too, which
+ * `draftMode().disable()` is not. Call it after `disable()`; it replaces
+ * `disable()`'s own deletion, since a response sets one cookie per name. A
+ * draft cookie set without `Partitioned`, before a site used
+ * `frameDraftCookie`, ends when the browser closes, as it always did.
+ */
+export declare function clearDraftCookie(cookies: CookiesFn): Promise<void>;
+/**
+ * `app/api/capa/preview/route.ts`:
+ *
+ *   import { cookies, draftMode } from "next/headers";
+ *   export const GET = createPreviewRoute({ draftMode, cookies });
+ *
+ * Checks the token with Capa (the site never holds the signing key), turns
+ * draft mode on and lands on the entry's page. A bad or expired token lands on
+ * the page without draft mode and `?preview=expired`; Capa unreachable gives
+ * `?preview=unavailable`. The token is checked with any key the site holds,
+ * its legacy key included (`getPublishedClient`, from `CAPA_KEY`).
+ *
+ * Given `cookies`, the draft cookie is re-set by `frameDraftCookie`: one hour,
+ * and sent inside the editor's frame. With no `redirect`, the route answers
+ * with its own 307, marked `X-Robots-Tag: noindex, nofollow`,
+ * `Referrer-Policy: no-referrer` (the token is in the URL),
+ * `Cache-Control: private, no-store` and the editor's `frame-ancestors`.
+ * Given Next's `redirect`, it is called instead, as before, and the redirect
+ * carries none of those.
+ */
+export declare function createPreviewRoute(input: {
+    draftMode: DraftModeFn;
+    /** Next's `cookies`. Given, the draft cookie lasts `maxAge` seconds and works in the editor's frame. */
+    cookies?: CookiesFn;
+    /** Next's `redirect`. Leave it out for a redirect that carries the draft headers. */
+    redirect?: (url: string) => never | void;
+    client?: () => Pick<CapaNextClient, "preview">;
+    /** Runs after draft mode is enabled and the cookie re-set, before the redirect (cookie tweaks). */
+    onEnable?: () => void | Promise<void>;
+    /** The origins allowed to frame a draft. `[CAPA_ADMIN_ORIGIN]` when left out. */
+    adminOrigins?: readonly string[];
+    /** Seconds the draft cookie lasts, given `cookies`. `DRAFT_COOKIE_MAX_AGE` (one hour) when left out. */
+    maxAge?: number;
+}): (request: Request) => Promise<Response | void>;
+/**
+ * `app/api/capa/exit/route.ts`:
+ *
+ *   import { cookies, draftMode } from "next/headers";
+ *   export const GET = exitPreviewRoute({ draftMode, cookies });
+ *
+ * Turns draft mode off and lands on `?path=`. Given `cookies`, the framed
+ * cookie `createPreviewRoute` set is deleted too. With no `redirect`, the route
+ * answers with its own 307, marked noindex and never cached.
+ */
+export declare function exitPreviewRoute(input: {
+    draftMode: DraftModeFn;
+    cookies?: CookiesFn;
+    redirect?: (url: string) => never | void;
+}): (request: Request) => Promise<Response | void>;
+interface MiddlewareRequest {
+    url: string;
+    headers: Headers;
+    nextUrl: URL & {
+        clone(): URL;
+    };
+    cookies: {
+        getAll(): Array<{
+            name: string;
+            value: string;
+        }>;
+    };
+}
+interface NextResponseLike {
+    next(init?: {
+        request?: {
+            headers?: Headers;
+        };
+    }): {
+        headers: Headers;
+    };
+    rewrite(url: URL): unknown;
+}
+/**
+ * `middleware.ts` in one line:
+ *
+ *   import { NextResponse } from "next/server";
+ *   export const middleware = capaMiddleware({ NextResponse });
+ *
+ * - `?capa-preview=<token>` on any page goes to `previewRoute`, which turns
+ *   draft mode on and comes back;
+ * - `?capa-view=published` renders without the draft cookie, for the editor's
+ *   Published view;
+ * - `?capa-edit=<token>` turns edit mode on (ids and overlay, published data);
+ * - every edit-mode response is `private, no-store`, and it and every request
+ *   carrying `capa-edit` or `capa-view` is `X-Robots-Tag: noindex, nofollow`.
+ *
+ * Give it a `matcher` so a visitor's request never runs it (Next reads
+ * `config` from the file itself, so it is written out there):
+ *
+ *   export const config = {
+ *     matcher: [
+ *       { source: "/:path*", has: [{ type: "query", key: "capa-preview" }] },
+ *       { source: "/:path*", has: [{ type: "query", key: "capa-edit" }] },
+ *       { source: "/:path*", has: [{ type: "query", key: "capa-view" }] },
+ *       { source: "/:path*", has: [{ type: "cookie", key: "__prerender_bypass" }] },
+ *     ],
+ *   };
+ */
+export declare function capaMiddleware(input: {
+    NextResponse: NextResponseLike;
+    previewRoute?: string;
+    client?: () => Pick<CapaNextClient, "preview">;
+}): (request: MiddlewareRequest) => Promise<unknown>;