next-safe-action/dist/index.d.mts

Type safe and validated Server Actions in your Next.js project.

import { Schema, Infer } from "./adapters/types.mjs";
import {
	M as MiddlewareFn,
	V as ValidationErrors,
	F as FlattenedBindArgsValidationErrors,
	D as DVES,
	S as SafeActionClientOpts,
	a as SafeActionClient,
} from "./index.types-Cct3QIs2.mjs";
export {
	B as BindArgsValidationErrors,
	o as FlattenedValidationErrors,
	p as HandleBindArgsValidationErrorsShapeFn,
	H as HandleValidationErrorsShapeFn,
	l as InferCtx,
	m as InferMetadata,
	k as InferMiddlewareFnNextCtx,
	I as InferSafeActionFnInput,
	j as InferSafeActionFnResult,
	n as InferServerError,
	f as MiddlewareResult,
	d as SafeActionFn,
	c as SafeActionResult,
	i as SafeActionUtils,
	e as SafeStateActionFn,
	g as ServerCodeFn,
	b as ServerErrorFunctionUtils,
	h as StateServerCodeFn,
} from "./index.types-Cct3QIs2.mjs";
import "@sinclair/typebox";
import "valibot";
import "yup";
import "zod";

/**
 * Creates a standalone middleware function. It accepts a generic object with optional `serverError`, `ctx` and `metadata`
 * properties, if you need one or all of them to be typed. The type for each property that is passed as generic is the
 * **minimum** shape required to define the middleware function, but it can also be larger than that.
 *
 * {@link https://next-safe-action.dev/docs/define-actions/middleware#create-standalone-middleware-with-createmiddleware See docs for more information}
 */
declare const createMiddleware: <
	BaseData extends {
		serverError?: any;
		ctx?: object;
		metadata?: any;
	},
>() => {
	define: <NextCtx extends object>(
		middlewareFn: MiddlewareFn<
			BaseData extends {
				serverError: infer SE;
			}
				? SE
				: any,
			BaseData extends {
				metadata: infer MD;
			}
				? MD
				: any,
			BaseData extends {
				ctx: infer Ctx extends object;
			}
				? Ctx
				: object,
			NextCtx
		>
	) => MiddlewareFn<
		BaseData extends {
			serverError: infer SE;
		}
			? SE
			: any,
		BaseData extends {
			metadata: infer MD;
		}
			? MD
			: any,
		BaseData extends {
			ctx: infer Ctx extends object;
		}
			? Ctx
			: object,
		NextCtx
	>;
};

declare const DEFAULT_SERVER_ERROR_MESSAGE = "Something went wrong while executing the operation.";

declare class ActionValidationError<CVE> extends Error {
	validationErrors: CVE;
	constructor(validationErrors: CVE);
}
/**
 * Return custom validation errors to the client from the action's server code function.
 * Code declared after this function invocation will not be executed.
 * @param schema Input schema
 * @param validationErrors Validation errors object
 *
 * {@link https://next-safe-action.dev/docs/define-actions/validation-errors#returnvalidationerrors See docs for more information}
 */
declare function returnValidationErrors<
	S extends Schema | (() => Promise<Schema>),
	AS extends Schema = S extends () => Promise<Schema> ? Awaited<ReturnType<S>> : S,
>(schema: S, validationErrors: ValidationErrors<AS>): never;
/**
 * Default validation errors format.
 * Emulation of `zod`'s [`format`](https://zod.dev/ERROR_HANDLING?id=formatting-errors) function.
 */
declare function formatValidationErrors<VE extends ValidationErrors<any>>(validationErrors: VE): VE;
/**
 * Default bind args validation errors format.
 * Emulation of `zod`'s [`format`](https://zod.dev/ERROR_HANDLING?id=formatting-errors) function.
 */
declare function formatBindArgsValidationErrors<BAVE extends readonly ValidationErrors<any>[]>(
	bindArgsValidationErrors: BAVE
): BAVE;
/**
 * Transform default formatted validation errors into flattened structure.
 * `formErrors` contains global errors, and `fieldErrors` contains errors for each field,
 * one level deep. It discards errors for nested fields.
 * Emulation of `zod`'s [`flatten`](https://zod.dev/ERROR_HANDLING?id=flattening-errors) function.
 * @param {ValidationErrors} [validationErrors] Validation errors object
 *
 * {@link https://next-safe-action.dev/docs/define-actions/validation-errors#flattenvalidationerrors-and-flattenbindargsvalidationerrors-utility-functions See docs for more information}
 */
declare function flattenValidationErrors<VE extends ValidationErrors<any>>(
	validationErrors: VE
): {
	formErrors: string[];
	fieldErrors: { [K in keyof Omit<VE, "_errors">]?: string[] | undefined };
};
/**
 * Transform default formatted bind arguments validation errors into flattened structure.
 * `formErrors` contains global errors, and `fieldErrors` contains errors for each field,
 * one level deep. It discards errors for nested fields.
 * Emulation of `zod`'s [`flatten`](https://zod.dev/ERROR_HANDLING?id=flattening-errors) function.
 * @param {ValidationErrors[]} [bindArgsValidationErrors] Bind arguments validation errors object
 *
 * {@link https://next-safe-action.dev/docs/define-actions/validation-errors#flattenvalidationerrors-and-flattenbindargsvalidationerrors-utility-functions See docs for more information}
 */
declare function flattenBindArgsValidationErrors<BAVE extends readonly ValidationErrors<any>[]>(
	bindArgsValidationErrors: BAVE
): FlattenedBindArgsValidationErrors<BAVE>;
/**
 * This error is thrown when an action metadata is invalid, i.e. when there's a mismatch between the
 * type of the metadata schema returned from `defineMetadataSchema` and the actual data passed.
 */
declare class ActionMetadataValidationError<MDS extends Schema | undefined> extends Error {
	validationErrors: ValidationErrors<MDS>;
	constructor(validationErrors: ValidationErrors<MDS>);
}
/**
 * This error is thrown when an action's data (output) is invalid, i.e. when there's a mismatch between the
 * type of the data schema passed to `dataSchema` method and the actual return of the action.
 */
declare class ActionOutputDataValidationError<DS extends Schema | undefined> extends Error {
	validationErrors: ValidationErrors<DS>;
	constructor(validationErrors: ValidationErrors<DS>);
}

/**
 * Create a new safe action client.
 * Note: this client only works with Zod as the validation library.
 * @param createOpts Initialization options
 *
 * {@link https://next-safe-action.dev/docs/define-actions/create-the-client#initialization-options See docs for more information}
 */
declare const createSafeActionClient: <
	ODVES extends DVES | undefined = undefined,
	ServerError = string,
	MetadataSchema extends Schema | undefined = undefined,
>(
	createOpts?: SafeActionClientOpts<ServerError, MetadataSchema, ODVES>
) => SafeActionClient<
	ServerError,
	ODVES,
	MetadataSchema,
	MetadataSchema extends Schema ? Infer<MetadataSchema> : undefined,
	{},
	undefined,
	undefined,
	undefined,
	readonly [],
	| {
			formErrors: string[];
			fieldErrors: {};
	  }
	| undefined,
	readonly []
>;

export {
	ActionMetadataValidationError,
	ActionOutputDataValidationError,
	ActionValidationError,
	DEFAULT_SERVER_ERROR_MESSAGE,
	DVES,
	FlattenedBindArgsValidationErrors,
	MiddlewareFn,
	SafeActionClient,
	SafeActionClientOpts,
	ValidationErrors,
	createMiddleware,
	createSafeActionClient,
	flattenBindArgsValidationErrors,
	flattenValidationErrors,
	formatBindArgsValidationErrors,
	formatValidationErrors,
	returnValidationErrors,
};