astro 4.7.1 → 4.8.0

package/client.d.ts

@@ -1,5 +1,6 @@
 /// <reference types="vite/types/import-meta.d.ts" />
 /// <reference path="./types/content.d.ts" />
+/// <reference path="./types/actions.d.ts" />
 
 // eslint-disable-next-line  @typescript-eslint/no-namespace
 declare namespace App {

package/content-module.template.mjs

@@ -48,10 +48,12 @@ const collectionToRenderEntryMap = createCollectionToGlobResultMap({
 	contentDir,
 });
 
+const cacheEntriesByCollection = new Map();
 export const getCollection = createGetCollection({
 	contentCollectionToEntryMap,
 	dataCollectionToEntryMap,
 	getRenderEntryImport: createGlobLookup(collectionToRenderEntryMap),
+	cacheEntriesByCollection,
 });
 
 export const getEntryBySlug = createGetEntryBySlug({

package/dist/@types/astro.d.ts

@@ -6,6 +6,7 @@ import type { MarkdownHeading, MarkdownVFile, RehypePlugins, RemarkPlugins, Rema
 import type * as babel from '@babel/core';
 import type * as rollup from 'rollup';
 import type * as vite from 'vite';
+import type { Accept, ActionClient, InputSchema } from '../actions/runtime/virtual/server.js';
 import type { RemotePattern } from '../assets/utils/remotePattern.js';
 import type { AssetsPrefix, SerializedSSRManifest } from '../core/app/types.js';
 import type { PageBuildData } from '../core/build/types.js';
@@ -19,7 +20,7 @@ import type { AstroPreferences } from '../preferences/index.js';
 import type { ToolbarAppEventTarget, ToolbarServerHelpers } from '../runtime/client/dev-toolbar/helpers.js';
 import type { AstroDevToolbar, DevToolbarCanvas } from '../runtime/client/dev-toolbar/toolbar.js';
 import type { Icon } from '../runtime/client/dev-toolbar/ui-library/icons.js';
-import type { DevToolbarBadge, DevToolbarButton, DevToolbarCard, DevToolbarHighlight, DevToolbarIcon, DevToolbarSelect, DevToolbarToggle, DevToolbarTooltip, DevToolbarWindow } from '../runtime/client/dev-toolbar/ui-library/index.js';
+import type { DevToolbarBadge, DevToolbarButton, DevToolbarCard, DevToolbarHighlight, DevToolbarIcon, DevToolbarRadioCheckbox, DevToolbarSelect, DevToolbarToggle, DevToolbarTooltip, DevToolbarWindow } from '../runtime/client/dev-toolbar/ui-library/index.js';
 import type { AstroComponentFactory, AstroComponentInstance } from '../runtime/server/index.js';
 import type { TransitionBeforePreparationEvent, TransitionBeforeSwapEvent } from '../transitions/events.js';
 import type { DeepPartial, OmitIndexSignature, Simplify } from '../type-utils.js';
@@ -165,6 +166,22 @@ export interface AstroGlobal<Props extends Record<string, any> = Record<string,
     response: ResponseInit & {
         readonly headers: Headers;
     };
+    /**
+     * Get an action result on the server when using a form POST.
+     * Expects the action function as a parameter.
+     * Returns a type-safe result with the action data when
+     * a matching POST request is received
+     * and `undefined` otherwise.
+     *
+     * Example usage:
+     *
+     * ```typescript
+     * import { actions } from 'astro:actions';
+     *
+     * const result = await Astro.getActionResult(actions.myAction);
+     * ```
+     */
+    getActionResult: AstroSharedContext['getActionResult'];
     /** Redirect to another page (**SSR Only**)
      *
      * Example usage:
@@ -177,6 +194,19 @@ export interface AstroGlobal<Props extends Record<string, any> = Record<string,
      * [Astro reference](https://docs.astro.build/en/guides/server-side-rendering/)
      */
     redirect: AstroSharedContext['redirect'];
+    /**
+     * It rewrites to another page. As opposed to redirects, the URL won't change, and Astro will render the HTML emitted
+     * by the rewritten URL passed as argument.
+     *
+     * ## Example
+     *
+     * ```js
+     * if (pageIsNotEnabled) {
+     * 	return Astro.rewrite('/fallback-page')
+     * }
+     * ```
+     */
+    rewrite: AstroSharedContext['rewrite'];
     /**
      * The <Astro.self /> element allows a component to reference itself recursively.
      *
@@ -1514,7 +1544,7 @@ export interface AstroUserConfig {
          */
         domains?: Record<string, string>;
     };
-    /** ⚠️ WARNING: SUBJECT TO CHANGE */
+    /** ! WARNING: SUBJECT TO CHANGE */
     db?: Config.Database;
     /**
      * @docs
@@ -1561,6 +1591,104 @@ export interface AstroUserConfig {
          * ```
          */
         directRenderScript?: boolean;
+        /**
+         * @docs
+         * @name experimental.actions
+         * @type {boolean}
+         * @default `false`
+         * @version 4.7.0
+         * @description
+         *
+         * Actions help you write type-safe backend functions you can call from anywhere. Enable server rendering [using the `output` property](https://docs.astro.build/en/basics/rendering-modes/#on-demand-rendered) and add the `actions` flag to the `experimental` object:
+         *
+         * ```js
+         * {
+         * 	 output: 'hybrid', // or 'server'
+         *   experimental: {
+         *     actions: true,
+         *   },
+         * }
+         * ```
+         *
+         * Declare all your actions in `src/actions/index.ts`. This file is the global actions handler.
+         *
+         * Define an action using the `defineAction()` utility from the `astro:actions` module. These accept the `handler` property to define your server-side request handler. If your action accepts arguments, apply the `input` property to validate parameters with Zod.
+         *
+         * This example defines two actions: `like` and `comment`. The `like` action accepts a JSON object with a `postId` string, while the `comment` action accepts [FormData](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest_API/Using_FormData_Objects) with `postId`, `author`, and `body` strings. Each `handler` updates your database and return a type-safe response.
+         *
+         * ```ts
+         * // src/actions/index.ts
+         * import { defineAction, z } from "astro:actions";
+         *
+         * export const server = {
+         *   like: defineAction({
+         *     input: z.object({ postId: z.string() }),
+         *     handler: async ({ postId }, context) => {
+         *       // update likes in db
+         *
+         *       return likes;
+         *     },
+         *   }),
+         *   comment: defineAction({
+         * 		 accept: 'form',
+         *     input: z.object({
+         *       postId: z.string(),
+         *       author: z.string(),
+         *       body: z.string(),
+         *     }),
+         *     handler: async ({ postId }, context) => {
+         *       // insert comments in db
+         *
+         *       return comment;
+         *     },
+         *   }),
+         * };
+         * ```
+         *
+         * Then, call an action from your client components using the `actions` object from `astro:actions`. You can pass a type-safe object when using JSON, or a [FormData](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest_API/Using_FormData_Objects) object when using `accept: 'form'` in your action definition:
+         *
+         * ```tsx "actions"
+         * // src/components/blog.tsx
+         * import { actions } from "astro:actions";
+         * import { useState } from "preact/hooks";
+         *
+         * export function Like({ postId }: { postId: string }) {
+         *   const [likes, setLikes] = useState(0);
+         *   return (
+         *     <button
+         *       onClick={async () => {
+         *         const newLikes = await actions.like({ postId });
+         *         setLikes(newLikes);
+         *       }}
+         *     >
+         *       {likes} likes
+         *     </button>
+         *   );
+         * }
+         *
+         * export function Comment({ postId }: { postId: string }) {
+         *   return (
+         *     <form
+         *       onSubmit={async (e) => {
+         *         e.preventDefault();
+         *         const formData = new FormData(e.target);
+         *         const result = await actions.blog.comment(formData);
+         *         // handle result
+         *       }}
+         *     >
+         *       <input type="hidden" name="postId" value={postId} />
+         *       <label for="author">Author</label>
+         *       <input id="author" type="text" name="author" />
+         *       <textarea rows={10} name="body"></textarea>
+         *       <button type="submit">Post</button>
+         *     </form>
+         *   );
+         * }
+         * ```
+         *
+         * For a complete overview, and to give feedback on this experimental API, see the [Actions RFC](https://github.com/withastro/roadmap/blob/actions/proposals/0046-actions.md).
+         */
+        actions?: boolean;
         /**
          * @docs
          * @name experimental.contentCollectionCache
@@ -1786,6 +1914,61 @@ export interface AstroUserConfig {
                 origin?: boolean;
             };
         };
+        /**
+         * @docs
+         * @name experimental.rewriting
+         * @type {boolean}
+         * @default `false`
+         * @version 4.8.0
+         * @description
+         *
+         * Enables a routing feature for rewriting requests in Astro pages, endpoints and Astro middleware, giving you programmatic control over your routes.
+         *
+         * ```js
+         * {
+         *   experimental: {
+         *     rewriting: true,
+         *   },
+         * }
+         * ```
+         *
+         * Use `Astro.rewrite` in your `.astro` files to reroute to a different page:
+         *
+         * ```astro "rewrite"
+         * ---
+         * // src/pages/dashboard.astro
+         * if (!Astro.props.allowed) {
+         * 	return Astro.rewrite("/")
+         * }
+         * ---
+         * ```
+         *
+         * Use `context.rewrite` in your endpoint files to reroute to a different page:
+         *
+         * ```js
+         * // src/pages/api.js
+         * export function GET(ctx) {
+         * 	if (!ctx.locals.allowed) {
+         * 		return ctx.rewrite("/")
+         * 	}
+         * }
+         * ```
+         *
+         * Use `next("/")` in your middleware file to reroute to a different page, and then call the next middleware function:
+         *
+         * ```js
+         * // src/middleware.js
+         * export function onRequest(ctx, next) {
+         * 	if (!ctx.cookies.get("allowed")) {
+         * 		return next("/") // new signature
+         * 	}
+         * 	return next();
+         * }
+         * ```
+         *
+         * For a complete overview, and to give feedback on this experimental API, see the [Rerouting RFC](https://github.com/withastro/roadmap/blob/feat/reroute/proposals/0047-rerouting.md).
+         */
+        rewriting: boolean;
     };
 }
 /**
@@ -2244,6 +2427,10 @@ interface AstroSharedContext<Props extends Record<string, any> = Record<string,
      * A full URL object of the request URL.
      */
     url: URL;
+    /**
+     * Get action result on the server when using a form POST.
+     */
+    getActionResult: <TAccept extends Accept, TInputSchema extends InputSchema<TAccept>, TAction extends ActionClient<unknown, TAccept, TInputSchema>>(action: TAction) => Awaited<ReturnType<TAction['safe']>> | undefined;
     /**
      * Route parameters for this request if this is a dynamic route.
      */
@@ -2256,6 +2443,19 @@ interface AstroSharedContext<Props extends Record<string, any> = Record<string,
      * Redirect to another page (**SSR Only**).
      */
     redirect(path: string, status?: ValidRedirectStatus): Response;
+    /**
+     * It rewrites to another page. As opposed to redirects, the URL won't change, and Astro will render the HTML emitted
+     * by the rerouted URL passed as argument.
+     *
+     * ## Example
+     *
+     * ```js
+     * if (pageIsNotEnabled) {
+     * 	return Astro.rewrite('/fallback-page')
+     * }
+     * ```
+     */
+    rewrite(rewritePayload: RewritePayload): Promise<Response>;
     /**
      * Object accessed via Astro middleware
      */
@@ -2361,6 +2561,20 @@ export interface APIContext<Props extends Record<string, any> = Record<string, a
      * [Reference](https://docs.astro.build/en/guides/api-reference/#contextredirect)
      */
     redirect: AstroSharedContext['redirect'];
+    /**
+     * It reroutes to another page. As opposed to redirects, the URL won't change, and Astro will render the HTML emitted
+     * by the rerouted URL passed as argument.
+     *
+     * ## Example
+     *
+     * ```ts
+     * // src/pages/secret.ts
+     * export function GET(ctx) {
+     *   return ctx.rewrite(new URL("../"), ctx.url);
+     * }
+     * ```
+     */
+    rewrite: AstroSharedContext['rewrite'];
     /**
      * An object that middlewares can use to store extra information related to the request.
      *
@@ -2539,7 +2753,8 @@ export interface AstroIntegration {
         }) => void | Promise<void>;
     };
 }
-export type MiddlewareNext = () => Promise<Response>;
+export type RewritePayload = string | URL | Request;
+export type MiddlewareNext = (rewritePayload?: RewritePayload) => Promise<Response>;
 export type MiddlewareHandler = (context: APIContext, next: MiddlewareNext) => Promise<Response> | Response | Promise<void> | void;
 export type AstroMiddlewareInstance = {
     onRequest?: MiddlewareHandler;
@@ -2764,6 +2979,7 @@ declare global {
         'astro-dev-toolbar-icon': DevToolbarIcon;
         'astro-dev-toolbar-card': DevToolbarCard;
         'astro-dev-toolbar-select': DevToolbarSelect;
+        'astro-dev-toolbar-radio-checkbox': DevToolbarRadioCheckbox;
         'astro-dev-overlay': AstroDevToolbar;
         'astro-dev-overlay-window': DevToolbarWindow;
         'astro-dev-overlay-plugin-canvas': DevToolbarCanvas;

package/dist/actions/consts.d.ts

@@ -0,0 +1,3 @@
+export declare const VIRTUAL_MODULE_ID = "astro:actions";
+export declare const RESOLVED_VIRTUAL_MODULE_ID: string;
+export declare const ACTIONS_TYPES_FILE = "actions.d.ts";

package/dist/actions/consts.js

@@ -0,0 +1,8 @@
+const VIRTUAL_MODULE_ID = "astro:actions";
+const RESOLVED_VIRTUAL_MODULE_ID = "\0" + VIRTUAL_MODULE_ID;
+const ACTIONS_TYPES_FILE = "actions.d.ts";
+export {
+  ACTIONS_TYPES_FILE,
+  RESOLVED_VIRTUAL_MODULE_ID,
+  VIRTUAL_MODULE_ID
+};

package/dist/actions/index.d.ts

@@ -0,0 +1,2 @@
+import type { AstroIntegration } from '../@types/astro.js';
+export default function astroActions(): AstroIntegration;

package/dist/actions/index.js

@@ -0,0 +1,72 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { ACTIONS_TYPES_FILE, RESOLVED_VIRTUAL_MODULE_ID, VIRTUAL_MODULE_ID } from "./consts.js";
+function astroActions() {
+  return {
+    name: VIRTUAL_MODULE_ID,
+    hooks: {
+      async "astro:config:setup"(params) {
+        const stringifiedActionsImport = JSON.stringify(
+          new URL("actions", params.config.srcDir).pathname
+        );
+        params.updateConfig({
+          vite: {
+            define: {
+              "import.meta.env.ACTIONS_PATH": stringifiedActionsImport
+            },
+            plugins: [vitePluginActions]
+          }
+        });
+        params.injectRoute({
+          pattern: "/_actions/[...path]",
+          entrypoint: "astro/actions/runtime/route.js",
+          prerender: false
+        });
+        params.addMiddleware({
+          entrypoint: "astro/actions/runtime/middleware.js",
+          order: "pre"
+        });
+        await typegen({
+          stringifiedActionsImport,
+          root: params.config.root
+        });
+      }
+    }
+  };
+}
+const vitePluginActions = {
+  name: VIRTUAL_MODULE_ID,
+  enforce: "pre",
+  resolveId(id) {
+    if (id === VIRTUAL_MODULE_ID) {
+      return RESOLVED_VIRTUAL_MODULE_ID;
+    }
+  },
+  async load(id, opts) {
+    if (id !== RESOLVED_VIRTUAL_MODULE_ID) return;
+    let code = await readFile(new URL("../../templates/actions.mjs", import.meta.url), "utf-8");
+    if (opts?.ssr) {
+      code += `
+export * from 'astro/actions/runtime/virtual/server.js';`;
+    } else {
+      code += `
+export * from 'astro/actions/runtime/virtual/client.js';`;
+    }
+    return code;
+  }
+};
+async function typegen({
+  stringifiedActionsImport,
+  root
+}) {
+  const content = `declare module "astro:actions" {
+	type Actions = typeof import(${stringifiedActionsImport})["server"];
+
+	export const actions: Actions;
+}`;
+  const dotAstroDir = new URL(".astro/", root);
+  await mkdir(dotAstroDir, { recursive: true });
+  await writeFile(new URL(ACTIONS_TYPES_FILE, dotAstroDir), content);
+}
+export {
+  astroActions as default
+};

package/dist/actions/runtime/middleware.d.ts

@@ -0,0 +1,7 @@
+import type { APIContext } from '../../@types/astro.js';
+export type Locals = {
+    _actionsInternal: {
+        getActionResult: APIContext['getActionResult'];
+    };
+};
+export declare const onRequest: import("../../@types/astro.js").MiddlewareHandler;

package/dist/actions/runtime/middleware.js

@@ -0,0 +1,38 @@
+import { defineMiddleware } from "../../core/middleware/index.js";
+import { ApiContextStorage } from "./store.js";
+import { formContentTypes, getAction, hasContentType } from "./utils.js";
+import { callSafely } from "./virtual/shared.js";
+const onRequest = defineMiddleware(async (context, next) => {
+  const locals = context.locals;
+  const { request, url } = context;
+  const contentType = request.headers.get("Content-Type");
+  if (url.pathname.startsWith("/_actions")) return nextWithLocalsStub(next, locals);
+  if (!contentType || !hasContentType(contentType, formContentTypes))
+    return nextWithLocalsStub(next, locals);
+  const formData = await request.clone().formData();
+  const actionPath = formData.get("_astroAction");
+  if (typeof actionPath !== "string") return nextWithLocalsStub(next, locals);
+  const actionPathKeys = actionPath.replace("/_actions/", "").split(".");
+  const action = await getAction(actionPathKeys);
+  const result = await ApiContextStorage.run(context, () => callSafely(() => action(formData)));
+  const actionsInternal = {
+    getActionResult: (actionFn) => {
+      if (actionFn.toString() !== actionPath) return Promise.resolve(void 0);
+      return result;
+    }
+  };
+  Object.defineProperty(locals, "_actionsInternal", { writable: false, value: actionsInternal });
+  return next();
+});
+function nextWithLocalsStub(next, locals) {
+  Object.defineProperty(locals, "_actionsInternal", {
+    writable: false,
+    value: {
+      getActionResult: () => void 0
+    }
+  });
+  return next();
+}
+export {
+  onRequest
+};

package/dist/actions/runtime/route.d.ts

@@ -0,0 +1,2 @@
+import type { APIRoute } from '../../@types/astro.js';
+export declare const POST: APIRoute;

package/dist/actions/runtime/route.js

@@ -0,0 +1,37 @@
+import { ApiContextStorage } from "./store.js";
+import { formContentTypes, getAction, hasContentType } from "./utils.js";
+import { callSafely } from "./virtual/shared.js";
+const POST = async (context) => {
+  const { request, url } = context;
+  const actionPathKeys = url.pathname.replace("/_actions/", "").split(".");
+  const action = await getAction(actionPathKeys);
+  const contentType = request.headers.get("Content-Type");
+  let args;
+  if (contentType && hasContentType(contentType, formContentTypes)) {
+    args = await request.clone().formData();
+  } else if (contentType && hasContentType(contentType, ["application/json"])) {
+    args = await request.clone().json();
+  } else {
+    return new Response(null, { status: 415 });
+  }
+  const result = await ApiContextStorage.run(context, () => callSafely(() => action(args)));
+  if (result.error) {
+    if (import.meta.env.PROD) {
+      result.error.stack = void 0;
+    }
+    return new Response(JSON.stringify(result.error), {
+      status: result.error.status,
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+  }
+  return new Response(JSON.stringify(result.data), {
+    headers: {
+      "Content-Type": "application/json"
+    }
+  });
+};
+export {
+  POST
+};

package/dist/actions/runtime/store.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="node" resolution-mode="require"/>
+import { AsyncLocalStorage } from 'node:async_hooks';
+import type { APIContext } from '../../@types/astro.js';
+export type ActionAPIContext = Omit<APIContext, 'getActionResult' | 'props'>;
+export declare const ApiContextStorage: AsyncLocalStorage<ActionAPIContext>;
+export declare function getApiContext(): ActionAPIContext;

package/dist/actions/runtime/store.js

@@ -0,0 +1,18 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { AstroError } from "../../core/errors/errors.js";
+const ApiContextStorage = new AsyncLocalStorage();
+function getApiContext() {
+  const context = ApiContextStorage.getStore();
+  if (!context) {
+    throw new AstroError({
+      name: "AstroActionError",
+      message: "Unable to get API context.",
+      hint: "If you attempted to call this action from server code, trying using `Astro.getActionResult()` instead."
+    });
+  }
+  return context;
+}
+export {
+  ApiContextStorage,
+  getApiContext
+};

package/dist/actions/runtime/utils.d.ts

@@ -0,0 +1,4 @@
+export declare const formContentTypes: string[];
+export declare function hasContentType(contentType: string, expected: string[]): boolean;
+export type MaybePromise<T> = T | Promise<T>;
+export declare function getAction(pathKeys: string[]): Promise<(param: unknown) => MaybePromise<unknown>>;

package/dist/actions/runtime/utils.js

@@ -0,0 +1,23 @@
+const formContentTypes = ["application/x-www-form-urlencoded", "multipart/form-data"];
+function hasContentType(contentType, expected) {
+  const type = contentType.split(";")[0].toLowerCase();
+  return expected.some((t) => type === t);
+}
+async function getAction(pathKeys) {
+  let { server: actionLookup } = await import(import.meta.env.ACTIONS_PATH);
+  for (const key of pathKeys) {
+    if (!(key in actionLookup)) {
+      throw new Error("Action not found");
+    }
+    actionLookup = actionLookup[key];
+  }
+  if (typeof actionLookup !== "function") {
+    throw new Error("Action not found");
+  }
+  return actionLookup;
+}
+export {
+  formContentTypes,
+  getAction,
+  hasContentType
+};

package/dist/actions/runtime/virtual/client.d.ts

@@ -0,0 +1,4 @@
+export * from './shared.js';
+export declare function defineAction(): void;
+export declare function getApiContext(): void;
+export declare const z: {};

package/dist/actions/runtime/virtual/client.js

@@ -0,0 +1,20 @@
+export * from "./shared.js";
+function defineAction() {
+  throw new Error("[astro:action] `defineAction()` unexpectedly used on the client.");
+}
+function getApiContext() {
+  throw new Error("[astro:action] `getApiContext()` unexpectedly used on the client.");
+}
+const z = new Proxy(
+  {},
+  {
+    get() {
+      throw new Error("[astro:action] `z` unexpectedly used on the client.");
+    }
+  }
+);
+export {
+  defineAction,
+  getApiContext,
+  z
+};

package/dist/actions/runtime/virtual/server.d.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import { type MaybePromise } from '../utils.js';
+import { type ErrorInferenceObject, type SafeResult } from './shared.js';
+export * from './shared.js';
+export { z } from 'zod';
+export { getApiContext } from '../store.js';
+export type Accept = 'form' | 'json';
+export type InputSchema<T extends Accept> = T extends 'form' ? z.AnyZodObject | z.ZodType<FormData> : z.ZodType;
+type Handler<TInputSchema, TOutput> = TInputSchema extends z.ZodType ? (input: z.infer<TInputSchema>) => MaybePromise<TOutput> : (input?: any) => MaybePromise<TOutput>;
+export type ActionClient<TOutput, TAccept extends Accept, TInputSchema extends InputSchema<TAccept> | undefined> = TInputSchema extends z.ZodType ? ((input: TAccept extends 'form' ? FormData : z.input<TInputSchema>) => Promise<Awaited<TOutput>>) & {
+    safe: (input: TAccept extends 'form' ? FormData : z.input<TInputSchema>) => Promise<SafeResult<z.input<TInputSchema> extends ErrorInferenceObject ? z.input<TInputSchema> : ErrorInferenceObject, Awaited<TOutput>>>;
+} : ((input?: any) => Promise<Awaited<TOutput>>) & {
+    safe: (input?: any) => Promise<SafeResult<never, Awaited<TOutput>>>;
+};
+export declare function defineAction<TOutput, TAccept extends Accept = 'json', TInputSchema extends InputSchema<Accept> | undefined = TAccept extends 'form' ? z.ZodType<FormData> : undefined>({ accept, input: inputSchema, handler, }: {
+    input?: TInputSchema;
+    accept?: TAccept;
+    handler: Handler<TInputSchema, TOutput>;
+}): ActionClient<TOutput, TAccept, TInputSchema>;
+/** Transform form data to an object based on a Zod schema. */
+export declare function formDataToObject<T extends z.AnyZodObject>(formData: FormData, schema: T): Record<string, unknown>;