@veloxts/validation 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 VeloxTS Framework Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,398 @@
+# @veloxts/validation
+
+Type-safe validation using Zod schemas for the VeloxTS framework.
+
+## Installation
+
+```bash
+npm install @veloxts/validation
+# or
+pnpm add @veloxts/validation
+```
+
+Note: Zod is a peer dependency and will be installed automatically if not already present.
+
+## Quick Start
+
+```typescript
+import { z, parse, InferOutput } from '@veloxts/validation';
+
+// Define a schema
+const UserSchema = z.object({
+  id: z.string().uuid(),
+  name: z.string().min(1),
+  email: z.string().email(),
+});
+
+// Infer the TypeScript type
+type User = InferOutput<typeof UserSchema>;
+
+// Parse and validate data
+const user = parse(UserSchema, {
+  id: '123e4567-e89b-012d-3456-426614174000',
+  name: 'Alice',
+  email: 'alice@example.com',
+});
+// user is typed as User and validated
+```
+
+## Core API
+
+### Validation Functions
+
+#### `parse(schema, data)`
+
+Parses data against a schema and throws a `ValidationError` if invalid.
+
+```typescript
+import { parse, ValidationError } from '@veloxts/validation';
+
+try {
+  const user = parse(UserSchema, untrustedData);
+  // user is valid and typed
+} catch (error) {
+  if (error instanceof ValidationError) {
+    console.log('Validation failed:', error.fields);
+    // error.fields contains field-specific error messages
+  }
+}
+```
+
+#### `safeParse(schema, data)`
+
+Parses data and returns a result object instead of throwing.
+
+```typescript
+import { safeParse } from '@veloxts/validation';
+
+const result = safeParse(UserSchema, untrustedData);
+
+if (result.success) {
+  console.log('Valid user:', result.data);
+} else {
+  console.log('Validation errors:', result.error.issues);
+}
+```
+
+### Common Schemas
+
+The package provides pre-built schemas for common use cases:
+
+```typescript
+import {
+  uuidSchema,
+  emailSchema,
+  urlSchema,
+  nonEmptyStringSchema,
+  datetimeSchema,
+  idParamSchema,
+  timestampFieldsSchema,
+} from '@veloxts/validation';
+
+// UUID validation
+const id = parse(uuidSchema, '123e4567-e89b-012d-3456-426614174000');
+
+// Email validation
+const email = parse(emailSchema, 'user@example.com');
+
+// URL validation
+const website = parse(urlSchema, 'https://example.com');
+
+// Non-empty string (trimmed, min 1 char)
+const name = parse(nonEmptyStringSchema, '  Alice  '); // "Alice"
+
+// ISO datetime string
+const timestamp = parse(datetimeSchema, '2025-01-01T00:00:00Z');
+
+// Route parameter validation (e.g., /users/:id)
+const params = parse(idParamSchema, { id: '123e4567-...' });
+
+// Standard timestamp fields for entities
+const EntitySchema = z.object({
+  id: uuidSchema,
+  name: nonEmptyStringSchema,
+}).merge(timestampFieldsSchema);
+```
+
+### Pagination Schemas
+
+Built-in support for offset-based and cursor-based pagination:
+
+```typescript
+import {
+  paginationInputSchema,
+  createPaginatedResponseSchema,
+  calculatePaginationMeta,
+  PAGINATION_DEFAULTS,
+} from '@veloxts/validation';
+
+// Input schema for pagination params
+const input = parse(paginationInputSchema, {
+  page: 1,
+  limit: 20, // default: 10, max: 100
+});
+
+// Create a paginated response schema
+const UserListSchema = createPaginatedResponseSchema(UserSchema);
+
+// Calculate pagination metadata
+const meta = calculatePaginationMeta({
+  page: 1,
+  limit: 10,
+  total: 95,
+});
+// { page: 1, limit: 10, total: 95, totalPages: 10, hasNext: true, hasPrev: false }
+
+// Use in procedure definitions
+export const userProcedures = defineProcedures('users', {
+  listUsers: procedure()
+    .input(paginationInputSchema)
+    .output(UserListSchema)
+    .query(async ({ input, ctx }) => {
+      const skip = (input.page - 1) * input.limit;
+      const [data, total] = await Promise.all([
+        ctx.db.user.findMany({ skip, take: input.limit }),
+        ctx.db.user.count(),
+      ]);
+
+      return {
+        data,
+        meta: calculatePaginationMeta({
+          page: input.page,
+          limit: input.limit,
+          total,
+        }),
+      };
+    }),
+});
+```
+
+### Schema Utilities
+
+#### Field Manipulation
+
+```typescript
+import { pickFields, omitFields, makePartial, partialExcept } from '@veloxts/validation';
+
+const UserSchema = z.object({
+  id: z.string().uuid(),
+  name: z.string(),
+  email: z.string().email(),
+  password: z.string(),
+  createdAt: z.string().datetime(),
+  updatedAt: z.string().datetime(),
+});
+
+// Pick specific fields
+const UserPublicSchema = pickFields(UserSchema, ['id', 'name', 'email']);
+// { id, name, email }
+
+// Omit fields
+const UserWithoutPassword = omitFields(UserSchema, ['password']);
+// { id, name, email, createdAt, updatedAt }
+
+// Make all fields optional
+const PartialUserSchema = makePartial(UserSchema);
+// All fields are optional
+
+// Make all fields optional except specified ones
+const UserUpdateSchema = partialExcept(UserSchema, ['id']);
+// id is required, all other fields are optional
+```
+
+#### Type Guards
+
+```typescript
+import { createTypeGuard } from '@veloxts/validation';
+
+const isUser = createTypeGuard(UserSchema);
+
+if (isUser(data)) {
+  // data is typed as User
+  console.log(data.name);
+}
+```
+
+### String Coercion Schemas
+
+Useful for parsing query parameters and form data:
+
+```typescript
+import {
+  numberStringSchema,
+  integerStringSchema,
+  booleanStringSchema,
+} from '@veloxts/validation';
+
+// Parse string to number
+const age = parse(numberStringSchema, '25'); // 25 (number)
+
+// Parse string to integer
+const count = parse(integerStringSchema, '42'); // 42 (number)
+
+// Parse string to boolean
+const enabled = parse(booleanStringSchema, 'true'); // true (boolean)
+// Accepts: "true", "false", "1", "0", "yes", "no"
+```
+
+## Using with Procedures
+
+Validation schemas integrate seamlessly with VeloxTS procedures:
+
+```typescript
+import { procedure, defineProcedures } from '@veloxts/router';
+import { z, emailSchema, nonEmptyStringSchema } from '@veloxts/validation';
+
+const CreateUserInput = z.object({
+  name: nonEmptyStringSchema,
+  email: emailSchema,
+  age: z.number().int().min(18).optional(),
+});
+
+export const userProcedures = defineProcedures('users', {
+  createUser: procedure()
+    .input(CreateUserInput)
+    .output(UserSchema)
+    .mutation(async ({ input, ctx }) => {
+      // input is automatically validated and typed
+      // { name: string, email: string, age?: number }
+      return ctx.db.user.create({ data: input });
+    }),
+});
+```
+
+## Type Inference
+
+The package provides type inference utilities for extracting types from schemas:
+
+```typescript
+import { InferInput, InferOutput } from '@veloxts/validation';
+
+const UserSchema = z.object({
+  email: z.string().email(),
+  age: z.number().transform((n) => n + 1),
+});
+
+// Input type (before transformation)
+type UserInput = InferInput<typeof UserSchema>;
+// { email: string; age: number }
+
+// Output type (after transformation)
+type UserOutput = InferOutput<typeof UserSchema>;
+// { email: string; age: number } (age is transformed)
+```
+
+## Error Handling
+
+Validation errors are automatically formatted with field-level details:
+
+```typescript
+import { ValidationError, parse } from '@veloxts/validation';
+
+const UserSchema = z.object({
+  name: z.string().min(2),
+  email: z.string().email(),
+  age: z.number().min(18),
+});
+
+try {
+  parse(UserSchema, {
+    name: 'A', // too short
+    email: 'invalid', // not an email
+    age: 16, // too young
+  });
+} catch (error) {
+  if (error instanceof ValidationError) {
+    console.log(error.message); // "Validation failed"
+    console.log(error.statusCode); // 400
+    console.log(error.fields);
+    // {
+    //   name: "String must contain at least 2 character(s)",
+    //   email: "Invalid email",
+    //   age: "Number must be greater than or equal to 18"
+    // }
+  }
+}
+```
+
+## Advanced Features
+
+### Custom Validators
+
+Create reusable validation functions:
+
+```typescript
+import { createValidator } from '@veloxts/validation';
+
+const validateUser = createValidator(UserSchema);
+
+// Use in middleware or handlers
+const user = validateUser(request.body);
+```
+
+### Schema Composition
+
+Build complex schemas from simpler ones:
+
+```typescript
+import { timestampFieldsSchema, baseEntitySchema } from '@veloxts/validation';
+import { z } from 'zod';
+
+const PostSchema = baseEntitySchema.extend({
+  title: z.string().min(1).max(200),
+  content: z.string().min(1),
+  authorId: z.string().uuid(),
+  published: z.boolean().default(false),
+});
+
+// baseEntitySchema includes: id (UUID), createdAt, updatedAt
+```
+
+## Configuration
+
+### Pagination Defaults
+
+Customize pagination defaults:
+
+```typescript
+import { PAGINATION_DEFAULTS } from '@veloxts/validation';
+
+console.log(PAGINATION_DEFAULTS);
+// {
+//   page: 1,
+//   limit: 10,
+//   maxLimit: 100,
+// }
+
+// Create custom pagination schema
+const customPaginationSchema = z.object({
+  page: z.number().int().min(1).default(1),
+  limit: z.number().int().min(1).max(50).default(25), // custom max
+});
+```
+
+## Best Practices
+
+1. **Define schemas once, reuse everywhere**: Share schemas between frontend and backend for consistent validation.
+
+2. **Use common schemas**: Leverage built-in schemas like `emailSchema`, `uuidSchema` for consistency.
+
+3. **Compose schemas**: Build complex schemas from simpler ones using `.extend()`, `.merge()`, and `.pick()`.
+
+4. **Validate early**: Use `input()` in procedures to validate at the API boundary.
+
+5. **Type inference**: Use `InferOutput` to extract TypeScript types instead of manually defining them.
+
+## Related Packages
+
+- [@veloxts/core](/packages/core) - Core framework with error classes
+- [@veloxts/router](/packages/router) - Procedure definitions using validation schemas
+- [@veloxts/client](/packages/client) - Type-safe API client with inferred types
+
+## TypeScript Support
+
+All exports are fully typed with comprehensive JSDoc documentation. The package includes type definitions and declaration maps for excellent IDE support.
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,35 @@
+/**
+ * @veloxts/validation - Zod integration for runtime validation
+ *
+ * Provides Zod-based validation with automatic type inference for
+ * procedure inputs/outputs and request validation.
+ *
+ * @example
+ * ```typescript
+ * import { z, parse, InferOutput } from '@veloxts/validation';
+ *
+ * const UserSchema = z.object({
+ *   id: z.string().uuid(),
+ *   name: z.string().min(1),
+ *   email: z.string().email(),
+ * });
+ *
+ * type User = InferOutput<typeof UserSchema>;
+ *
+ * const user = parse(UserSchema, data);
+ * // user is typed as User
+ * ```
+ *
+ * @module @veloxts/validation
+ */
+export { ZodError, type ZodType, type ZodTypeDef, z } from 'zod';
+export declare const VALIDATION_VERSION: "0.1.0";
+export type { AnySchema, AnyZodSchema, InferInput, InferOutput, NoInput, ResolveInput, ResolveOutput, SafeParseError, SafeParseResult, SafeParseSuccess, Schema, SchemaLike, UnknownOutput, ValidationIssue, } from './types.js';
+export { isSchema, isZodSchema, wrapSchema } from './types.js';
+export type { Validator } from './middleware.js';
+export { assertSchema, createTypeGuard, createValidator, formatZodErrors, parse, parseAll, safeParse, safeValidate, validate, validateAll, zodErrorToValidationError, } from './middleware.js';
+export type { BaseEntity, IdParam, TimestampFields } from './schemas/common.js';
+export { baseEntitySchema, booleanStringSchema, createIdSchema, datetimeSchema, emailSchema, idParamSchema, integerStringSchema, makePartial, nonEmptyStringSchema, numberStringSchema, omitFields, partialExcept, pickFields, timestampFieldsSchema, urlSchema, uuidSchema, } from './schemas/common.js';
+export type { CursorPaginatedResponse, CursorPaginationInput, CursorPaginationMeta, PaginatedResponse, PaginationInput, PaginationMeta, } from './schemas/pagination.js';
+export { calculateOffset, calculatePaginationMeta, createCursorPaginatedResponseSchema, createPaginatedResponse, createPaginatedResponseSchema, createPaginationSchema, cursorPaginationSchema, PAGINATION_DEFAULTS, paginationInputSchema, } from './schemas/pagination.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAIH,OAAO,EAAE,QAAQ,EAAE,KAAK,OAAO,EAAE,KAAK,UAAU,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGjE,eAAO,MAAM,kBAAkB,EAAG,OAAgB,CAAC;AAMnD,YAAY,EAEV,SAAS,EACT,YAAY,EACZ,UAAU,EACV,WAAW,EACX,OAAO,EACP,YAAY,EACZ,aAAa,EAEb,cAAc,EACd,eAAe,EACf,gBAAgB,EAChB,MAAM,EACN,UAAU,EACV,aAAa,EACb,eAAe,GAChB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAU/D,YAAY,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAGjD,OAAO,EACL,YAAY,EACZ,eAAe,EACf,eAAe,EACf,eAAe,EACf,KAAK,EACL,QAAQ,EACR,SAAS,EACT,YAAY,EACZ,QAAQ,EACR,WAAW,EACX,yBAAyB,GAC1B,MAAM,iBAAiB,CAAC;AAMzB,YAAY,EAAE,UAAU,EAAE,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAChF,OAAO,EACL,gBAAgB,EAChB,mBAAmB,EACnB,cAAc,EACd,cAAc,EACd,WAAW,EACX,aAAa,EACb,mBAAmB,EACnB,WAAW,EACX,oBAAoB,EACpB,kBAAkB,EAClB,UAAU,EACV,aAAa,EACb,UAAU,EACV,qBAAqB,EACrB,SAAS,EACT,UAAU,GACX,MAAM,qBAAqB,CAAC;AAM7B,YAAY,EACV,uBAAuB,EACvB,qBAAqB,EACrB,oBAAoB,EACpB,iBAAiB,EACjB,eAAe,EACf,cAAc,GACf,MAAM,yBAAyB,CAAC;AACjC,OAAO,EACL,eAAe,EACf,uBAAuB,EACvB,mCAAmC,EACnC,uBAAuB,EACvB,6BAA6B,EAC7B,sBAAsB,EACtB,sBAAsB,EACtB,mBAAmB,EACnB,qBAAqB,GACtB,MAAM,yBAAyB,CAAC"}

package/dist/index.js

@@ -0,0 +1,36 @@
+/**
+ * @veloxts/validation - Zod integration for runtime validation
+ *
+ * Provides Zod-based validation with automatic type inference for
+ * procedure inputs/outputs and request validation.
+ *
+ * @example
+ * ```typescript
+ * import { z, parse, InferOutput } from '@veloxts/validation';
+ *
+ * const UserSchema = z.object({
+ *   id: z.string().uuid(),
+ *   name: z.string().min(1),
+ *   email: z.string().email(),
+ * });
+ *
+ * type User = InferOutput<typeof UserSchema>;
+ *
+ * const user = parse(UserSchema, data);
+ * // user is typed as User
+ * ```
+ *
+ * @module @veloxts/validation
+ */
+// Re-export Zod for convenience
+// Users can import { z } from '@veloxts/validation' instead of installing zod separately
+export { ZodError, z } from 'zod';
+// Version constant
+export const VALIDATION_VERSION = '0.1.0';
+export { isSchema, isZodSchema, wrapSchema } from './types.js';
+// Primary API - parse functions (Zod naming convention)
+// Deprecated aliases for backwards compatibility
+export { assertSchema, createTypeGuard, createValidator, formatZodErrors, parse, parseAll, safeParse, safeValidate, validate, validateAll, zodErrorToValidationError, } from './middleware.js';
+export { baseEntitySchema, booleanStringSchema, createIdSchema, datetimeSchema, emailSchema, idParamSchema, integerStringSchema, makePartial, nonEmptyStringSchema, numberStringSchema, omitFields, partialExcept, pickFields, timestampFieldsSchema, urlSchema, uuidSchema, } from './schemas/common.js';
+export { calculateOffset, calculatePaginationMeta, createCursorPaginatedResponseSchema, createPaginatedResponse, createPaginatedResponseSchema, createPaginationSchema, cursorPaginationSchema, PAGINATION_DEFAULTS, paginationInputSchema, } from './schemas/pagination.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,gCAAgC;AAChC,yFAAyF;AACzF,OAAO,EAAE,QAAQ,EAAiC,CAAC,EAAE,MAAM,KAAK,CAAC;AAEjE,mBAAmB;AACnB,MAAM,CAAC,MAAM,kBAAkB,GAAG,OAAgB,CAAC;AAwBnD,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAW/D,wDAAwD;AACxD,iDAAiD;AACjD,OAAO,EACL,YAAY,EACZ,eAAe,EACf,eAAe,EACf,eAAe,EACf,KAAK,EACL,QAAQ,EACR,SAAS,EACT,YAAY,EACZ,QAAQ,EACR,WAAW,EACX,yBAAyB,GAC1B,MAAM,iBAAiB,CAAC;AAOzB,OAAO,EACL,gBAAgB,EAChB,mBAAmB,EACnB,cAAc,EACd,cAAc,EACd,WAAW,EACX,aAAa,EACb,mBAAmB,EACnB,WAAW,EACX,oBAAoB,EACpB,kBAAkB,EAClB,UAAU,EACV,aAAa,EACb,UAAU,EACV,qBAAqB,EACrB,SAAS,EACT,UAAU,GACX,MAAM,qBAAqB,CAAC;AAc7B,OAAO,EACL,eAAe,EACf,uBAAuB,EACvB,mCAAmC,EACnC,uBAAuB,EACvB,6BAA6B,EAC7B,sBAAsB,EACtB,sBAAsB,EACtB,mBAAmB,EACnB,qBAAqB,GACtB,MAAM,yBAAyB,CAAC"}

package/dist/middleware.d.ts

@@ -0,0 +1,174 @@
+/**
+ * Validation middleware for VeloxTS procedures and routes
+ *
+ * Provides middleware utilities for validating request data
+ * with proper error handling and type inference.
+ *
+ * @module middleware
+ */
+import { ValidationError } from '@veloxts/core';
+import { ZodError, type ZodType, type ZodTypeDef } from 'zod';
+import type { AnySchema, AnyZodSchema, SafeParseResult } from './types.js';
+/**
+ * Transforms Zod validation issues into a field-error map
+ *
+ * @param issues - Array of Zod validation issues
+ * @returns Record mapping field paths to error messages
+ */
+export declare function formatZodErrors(issues: readonly {
+    path: readonly (string | number)[];
+    message: string;
+}[]): Record<string, string>;
+/**
+ * Transforms a ZodError into a VeloxTSValidationError
+ *
+ * @param error - ZodError from failed validation
+ * @param customMessage - Optional custom error message
+ * @returns ValidationError with field-specific errors
+ */
+export declare function zodErrorToValidationError(error: ZodError, customMessage?: string): ValidationError;
+/**
+ * Parses and validates data against a schema, throwing ValidationError on failure
+ *
+ * Follows Zod's naming convention for consistency with the ecosystem.
+ *
+ * @template T - The validated output type
+ * @param schema - Zod schema or Schema wrapper
+ * @param data - Data to validate
+ * @param errorMessage - Optional custom error message
+ * @returns Validated data with proper type
+ * @throws ValidationError if validation fails
+ *
+ * @example
+ * ```typescript
+ * const UserSchema = z.object({ name: z.string(), email: z.string().email() });
+ *
+ * const user = parse(UserSchema, request.body);
+ * // user is typed as { name: string; email: string }
+ * ```
+ */
+export declare function parse<T>(schema: ZodType<T, ZodTypeDef, unknown> | AnySchema, data: unknown, errorMessage?: string): T;
+/**
+ * @deprecated Use `parse` instead. This alias will be removed in v1.0.
+ */
+export declare const validate: typeof parse;
+/**
+ * Safely parses data without throwing
+ *
+ * Follows Zod's naming convention for consistency with the ecosystem.
+ *
+ * @template T - The validated output type
+ * @param schema - Zod schema or Schema wrapper
+ * @param data - Data to validate
+ * @returns Safe parse result with success discriminator
+ *
+ * @example
+ * ```typescript
+ * const result = safeParse(UserSchema, request.body);
+ * if (result.success) {
+ *   console.log(result.data.name);
+ * } else {
+ *   console.log(result.error);
+ * }
+ * ```
+ */
+export declare function safeParse<T>(schema: ZodType<T, ZodTypeDef, unknown> | AnySchema, data: unknown): SafeParseResult<T>;
+/**
+ * @deprecated Use `safeParse` instead. This alias will be removed in v1.0.
+ */
+export declare const safeValidate: typeof safeParse;
+/**
+ * Creates a reusable validator function from a schema
+ *
+ * @template TOutput - The validated output type
+ * @template TInput - The input type (defaults to unknown)
+ * @param schema - Zod schema for validation
+ * @returns Object with parse and safeParse methods
+ *
+ * @example
+ * ```typescript
+ * const userValidator = createValidator(UserSchema);
+ *
+ * // In a handler
+ * const user = userValidator.parse(request.body);
+ * ```
+ */
+export declare function createValidator<TOutput, TInput = unknown>(schema: ZodType<TOutput, ZodTypeDef, TInput>): Validator<TOutput>;
+/**
+ * Validator interface for type-safe validation
+ */
+export interface Validator<T> {
+    /** Parses data, throwing ValidationError on failure */
+    parse(data: unknown): T;
+    /** Safely parses data without throwing */
+    safeParse(data: unknown): SafeParseResult<T>;
+    /** @deprecated Use `parse` instead */
+    validate(data: unknown): T;
+    /** @deprecated Use `safeParse` instead */
+    safeValidate(data: unknown): SafeParseResult<T>;
+    /** The underlying Zod schema */
+    schema: AnyZodSchema;
+}
+/**
+ * Parses multiple data sources at once
+ *
+ * Useful for validating body, query, and params together.
+ *
+ * @param validations - Object mapping names to schema/data pairs
+ * @returns Object with validated data for each key
+ * @throws ValidationError with combined errors if any validation fails
+ *
+ * @example
+ * ```typescript
+ * const { body, query, params } = parseAll({
+ *   body: [CreateUserSchema, request.body],
+ *   query: [PaginationSchema, request.query],
+ *   params: [IdParamSchema, request.params],
+ * });
+ * ```
+ */
+export declare function parseAll<T extends Record<string, [AnyZodSchema, unknown]>>(validations: T): {
+    [K in keyof T]: T[K][0] extends ZodType<infer O, ZodTypeDef, unknown> ? O : never;
+};
+/**
+ * @deprecated Use `parseAll` instead. This alias will be removed in v1.0.
+ */
+export declare const validateAll: typeof parseAll;
+/**
+ * Creates a type guard from a Zod schema
+ *
+ * @template T - The validated type
+ * @param schema - Zod schema to use for checking
+ * @returns Type predicate function
+ *
+ * @example
+ * ```typescript
+ * const isUser = createTypeGuard(UserSchema);
+ *
+ * if (isUser(data)) {
+ *   // data is typed as User
+ *   console.log(data.name);
+ * }
+ * ```
+ */
+export declare function createTypeGuard<T>(schema: ZodType<T, ZodTypeDef, unknown>): (value: unknown) => value is T;
+/**
+ * Asserts that a value matches a schema, narrowing the type
+ *
+ * @template T - The validated type
+ * @param schema - Zod schema to validate against
+ * @param value - Value to assert
+ * @param errorMessage - Optional custom error message
+ * @throws ValidationError if assertion fails
+ *
+ * @example
+ * ```typescript
+ * function processUser(data: unknown) {
+ *   assertSchema(UserSchema, data);
+ *   // data is now typed as User
+ *   console.log(data.name);
+ * }
+ * ```
+ */
+export declare function assertSchema<T>(schema: ZodType<T, ZodTypeDef, unknown>, value: unknown, errorMessage?: string): asserts value is T;
+//# sourceMappingURL=middleware.d.ts.map

package/dist/middleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"middleware.d.ts","sourceRoot":"","sources":["../src/middleware.ts"],"names":[],"mappings":"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"}