@veloxts/validation 0.6.102 → 0.6.104

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @veloxts/validation
 
+## 0.6.104
+
+### Patch Changes
+
+- feat(client): smart convention-based route inference, eliminate routes.ts
+- Updated dependencies
+  - @veloxts/core@0.6.104
+
+## 0.6.103
+
+### Patch Changes
+
+- chore(deps): upgrade Zod from v3 to v4
+- Updated dependencies
+  - @veloxts/core@0.6.103
+
 ## 0.6.102
 
 ### Patch Changes

package/dist/index.d.ts

@@ -22,7 +22,7 @@
  *
  * @module @veloxts/validation
  */
-export { ZodError, type ZodType, type ZodTypeDef, z } from 'zod';
+export { ZodError, type ZodType, z } from 'zod';
 /** Validation package version */
 export declare const VALIDATION_VERSION: string;
 export type { AnySchema, AnyZodSchema, InferInput, InferOutput, NoInput, ResolveInput, ResolveOutput, SafeParseError, SafeParseResult, SafeParseSuccess, Schema, SchemaLike, UnknownOutput, ValidationIssue, } from './types.js';

package/dist/middleware.d.ts

@@ -7,7 +7,7 @@
  * @module middleware
  */
 import { ValidationError } from '@veloxts/core';
-import { ZodError, type ZodType, type ZodTypeDef } from 'zod';
+import { ZodError, type ZodType } from 'zod';
 import type { AnySchema, AnyZodSchema, SafeParseResult } from './types.js';
 /**
  * Transforms Zod validation issues into a field-error map
@@ -47,7 +47,9 @@ export declare function zodErrorToValidationError(error: ZodError, customMessage
  * // user is typed as { name: string; email: string }
  * ```
  */
-export declare function parse<T>(schema: ZodType<T, ZodTypeDef, unknown> | AnySchema, data: unknown, errorMessage?: string): T;
+export declare function parse<T>(schema: (ZodType & {
+    parse: (data: unknown) => T;
+}) | AnySchema, data: unknown, errorMessage?: string): T;
 /**
  * Safely parses data without throwing
  *
@@ -68,7 +70,9 @@ export declare function parse<T>(schema: ZodType<T, ZodTypeDef, unknown> | AnySc
  * }
  * ```
  */
-export declare function safeParse<T>(schema: ZodType<T, ZodTypeDef, unknown> | AnySchema, data: unknown): SafeParseResult<T>;
+export declare function safeParse<T>(schema: (ZodType & {
+    parse: (data: unknown) => T;
+}) | AnySchema, data: unknown): SafeParseResult<T>;
 /**
  * Creates a reusable validator function from a schema
  *
@@ -85,7 +89,9 @@ export declare function safeParse<T>(schema: ZodType<T, ZodTypeDef, unknown> | A
  * const user = userValidator.parse(request.body);
  * ```
  */
-export declare function createValidator<TOutput, TInput = unknown>(schema: ZodType<TOutput, ZodTypeDef, TInput>): Validator<TOutput>;
+export declare function createValidator<TOutput>(schema: ZodType & {
+    parse: (data: unknown) => TOutput;
+}): Validator<TOutput>;
 /**
  * Validator interface for type-safe validation
  */
@@ -116,7 +122,9 @@ export interface Validator<T> {
  * ```
  */
 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;
+    [K in keyof T]: T[K][0] extends {
+        parse: (data: unknown) => infer O;
+    } ? O : never;
 };
 /**
  * Creates a type guard from a Zod schema
@@ -135,7 +143,9 @@ export declare function parseAll<T extends Record<string, [AnyZodSchema, unknown
  * }
  * ```
  */
-export declare function createTypeGuard<T>(schema: ZodType<T, ZodTypeDef, unknown>): (value: unknown) => value is T;
+export declare function createTypeGuard<T>(schema: ZodType & {
+    parse: (data: unknown) => T;
+}): (value: unknown) => value is T;
 /**
  * Asserts that a value matches a schema, narrowing the type
  *
@@ -154,4 +164,6 @@ export declare function createTypeGuard<T>(schema: ZodType<T, ZodTypeDef, unknow
  * }
  * ```
  */
-export declare function assertSchema<T>(schema: ZodType<T, ZodTypeDef, unknown>, value: unknown, errorMessage?: string): asserts value is T;
+export declare function assertSchema<T>(schema: ZodType & {
+    parse: (data: unknown) => T;
+}, value: unknown, errorMessage?: string): asserts value is T;

package/dist/middleware.js

@@ -37,7 +37,10 @@ export function formatZodErrors(issues) {
  * @returns ValidationError with field-specific errors
  */
 export function zodErrorToValidationError(error, customMessage) {
-    const fields = formatZodErrors(error.issues);
+    const fields = formatZodErrors(error.issues.map((i) => ({
+        path: i.path.filter((p) => typeof p !== 'symbol'),
+        message: i.message,
+    })));
     const message = customMessage ?? 'Validation failed';
     return new ValidationError(message, fields);
 }
@@ -121,7 +124,7 @@ export function safeParse(schema, data) {
         return {
             success: false,
             error: result.error.issues.map((issue) => ({
-                path: issue.path,
+                path: issue.path.filter((p) => typeof p !== 'symbol'),
                 message: issue.message,
                 code: issue.code,
             })),

package/dist/schemas/common.d.ts

@@ -38,11 +38,7 @@ export declare const datetimeSchema: z.ZodString;
  */
 export declare const idParamSchema: z.ZodObject<{
     id: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    id: string;
-}, {
-    id: string;
-}>;
+}, z.core.$strip>;
 /**
  * Type for id parameter objects
  */
@@ -53,20 +49,14 @@ export type IdParam = z.infer<typeof idParamSchema>;
  * @param type - Type of ID to accept ('uuid' | 'integer' | 'string')
  * @returns Zod schema for the specified ID type
  */
-export declare function createIdSchema<T extends 'uuid' | 'integer' | 'string'>(type: T): T extends 'uuid' ? typeof uuidSchema : T extends 'integer' ? z.ZodPipeline<z.ZodEffects<z.ZodString, number, string>, z.ZodNumber> : z.ZodString;
+export declare function createIdSchema<T extends 'uuid' | 'integer' | 'string'>(type: T): T extends 'uuid' ? typeof uuidSchema : T extends 'integer' ? z.ZodType<number, unknown> : z.ZodString;
 /**
  * Timestamp fields commonly added to database records
  */
 export declare const timestampFieldsSchema: z.ZodObject<{
-    createdAt: z.ZodDate;
-    updatedAt: z.ZodDate;
-}, "strip", z.ZodTypeAny, {
-    createdAt: Date;
-    updatedAt: Date;
-}, {
-    createdAt: Date;
-    updatedAt: Date;
-}>;
+    createdAt: z.ZodCoercedDate<unknown>;
+    updatedAt: z.ZodCoercedDate<unknown>;
+}, z.core.$strip>;
 /**
  * Type for timestamp fields
  */
@@ -76,17 +66,9 @@ export type TimestampFields = z.infer<typeof timestampFieldsSchema>;
  */
 export declare const baseEntitySchema: z.ZodObject<{
     id: z.ZodString;
-    createdAt: z.ZodDate;
-    updatedAt: z.ZodDate;
-}, "strip", z.ZodTypeAny, {
-    id: string;
-    createdAt: Date;
-    updatedAt: Date;
-}, {
-    id: string;
-    createdAt: Date;
-    updatedAt: Date;
-}>;
+    createdAt: z.ZodCoercedDate<unknown>;
+    updatedAt: z.ZodCoercedDate<unknown>;
+}, z.core.$strip>;
 /**
  * Type for base entity
  */
@@ -154,14 +136,14 @@ export declare function pickFields<T extends z.ZodRawShape, K extends keyof T &
  * String that coerces to boolean
  * Accepts 'true', '1', 'yes' as true; 'false', '0', 'no' as false
  */
-export declare const booleanStringSchema: z.ZodPipeline<z.ZodEffects<z.ZodString, boolean | undefined, string>, z.ZodBoolean>;
+export declare const booleanStringSchema: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<boolean | undefined, string>>, z.ZodBoolean>;
 /**
  * String that coerces to number
  * Useful for query parameters
  */
-export declare const numberStringSchema: z.ZodPipeline<z.ZodEffects<z.ZodString, number, string>, z.ZodNumber>;
+export declare const numberStringSchema: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>, z.ZodNumber>;
 /**
  * String that coerces to integer
  * Useful for pagination parameters
  */
-export declare const integerStringSchema: z.ZodPipeline<z.ZodEffects<z.ZodString, number, string>, z.ZodNumber>;
+export declare const integerStringSchema: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>, z.ZodNumber>;

package/dist/schemas/common.js

@@ -85,6 +85,20 @@ export const baseEntitySchema = z.object({
 // ============================================================================
 // Schema Composition Utilities
 // ============================================================================
+/**
+ * Builds a `{ key: true }` mask from an array of string keys.
+ *
+ * Zod 4's `.partial()`, `.omit()`, and `.pick()` accept a mask object whose
+ * exact type is derived from the schema's shape. We build a plain
+ * `Record<string, true>` at runtime and cast it to the schema-specific mask
+ * type at each call-site via `Parameters<typeof schema.method>[0]`.
+ */
+function buildMask(keys) {
+    const mask = {};
+    for (const key of keys)
+        mask[key] = true;
+    return mask;
+}
 /**
  * Makes all fields in a schema optional
  *
@@ -114,18 +128,8 @@ export function makePartial(schema) {
  * ```
  */
 export function partialExcept(schema, keys) {
-    const shape = schema.shape;
-    const requiredKeys = new Set(keys);
-    const newShape = {};
-    for (const key in shape) {
-        if (requiredKeys.has(key)) {
-            newShape[key] = shape[key];
-        }
-        else {
-            newShape[key] = shape[key].optional();
-        }
-    }
-    return z.object(newShape);
+    const keysToOptional = Object.keys(schema.shape).filter((k) => !keys.includes(k));
+    return schema.partial(buildMask(keysToOptional));
 }
 /**
  * Omits specified fields from a schema
@@ -140,16 +144,7 @@ export function partialExcept(schema, keys) {
  * ```
  */
 export function omitFields(schema, keys) {
-    // Build the omit mask manually to avoid Zod's strict typing
-    const shape = schema.shape;
-    const keysToOmit = new Set(keys);
-    const newShape = {};
-    for (const key in shape) {
-        if (!keysToOmit.has(key)) {
-            newShape[key] = shape[key];
-        }
-    }
-    return z.object(newShape);
+    return schema.omit(buildMask(keys));
 }
 /**
  * Picks specified fields from a schema
@@ -164,15 +159,7 @@ export function omitFields(schema, keys) {
  * ```
  */
 export function pickFields(schema, keys) {
-    // Build the pick mask manually to avoid Zod's strict typing
-    const shape = schema.shape;
-    const newShape = {};
-    for (const key of keys) {
-        if (key in shape) {
-            newShape[key] = shape[key];
-        }
-    }
-    return z.object(newShape);
+    return schema.pick(buildMask(keys));
 }
 // ============================================================================
 // Coercion Utilities

package/dist/schemas/pagination.d.ts

@@ -40,34 +40,18 @@ export declare function createPaginationSchema(options?: {
     defaultLimit?: number;
     maxLimit?: number;
 }): z.ZodObject<{
-    /** Current page number (1-indexed) */
-    page: z.ZodDefault<z.ZodNumber>;
-    /** Number of items per page */
-    limit: z.ZodDefault<z.ZodNumber>;
-}, "strip", z.ZodTypeAny, {
-    page: number;
-    limit: number;
-}, {
-    page?: number | undefined;
-    limit?: number | undefined;
-}>;
+    page: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
 /**
  * Default pagination input schema
  *
  * Accepts page (default 1) and limit (default 20, max 100)
  */
 export declare const paginationInputSchema: z.ZodObject<{
-    /** Current page number (1-indexed) */
-    page: z.ZodDefault<z.ZodNumber>;
-    /** Number of items per page */
-    limit: z.ZodDefault<z.ZodNumber>;
-}, "strip", z.ZodTypeAny, {
-    page: number;
-    limit: number;
-}, {
-    page?: number | undefined;
-    limit?: number | undefined;
-}>;
+    page: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
 /**
  * Type for pagination input
  */
@@ -78,21 +62,13 @@ export type PaginationInput = z.infer<typeof paginationInputSchema>;
  * For more efficient pagination of large datasets
  */
 export declare const cursorPaginationSchema: z.ZodObject<{
-    /** Cursor for the current position */
     cursor: z.ZodOptional<z.ZodString>;
-    /** Number of items to fetch */
-    limit: z.ZodDefault<z.ZodNumber>;
-    /** Direction to fetch (forward/backward from cursor) */
-    direction: z.ZodDefault<z.ZodEnum<["forward", "backward"]>>;
-}, "strip", z.ZodTypeAny, {
-    limit: number;
-    direction: "forward" | "backward";
-    cursor?: string | undefined;
-}, {
-    limit?: number | undefined;
-    cursor?: string | undefined;
-    direction?: "forward" | "backward" | undefined;
-}>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    direction: z.ZodDefault<z.ZodEnum<{
+        forward: "forward";
+        backward: "backward";
+    }>>;
+}, z.core.$strip>;
 /**
  * Type for cursor-based pagination input
  */
@@ -112,53 +88,16 @@ export type CursorPaginationInput = z.infer<typeof cursorPaginationSchema>;
  * // { data: User[]; meta: { page, limit, total, totalPages, hasMore } }
  * ```
  */
-export declare function createPaginatedResponseSchema<T extends z.ZodTypeAny>(itemSchema: T): z.ZodObject<{
-    /** Array of items for the current page */
-    data: z.ZodArray<T, "many">;
-    /** Pagination metadata */
+export declare function createPaginatedResponseSchema<T extends z.ZodType>(itemSchema: T): z.ZodObject<{
+    data: z.ZodArray<T>;
     meta: z.ZodObject<{
-        /** Current page number */
         page: z.ZodNumber;
-        /** Items per page */
         limit: z.ZodNumber;
-        /** Total number of items across all pages */
         total: z.ZodNumber;
-        /** Total number of pages */
         totalPages: z.ZodNumber;
-        /** Whether there are more pages after this one */
         hasMore: z.ZodBoolean;
-    }, "strip", z.ZodTypeAny, {
-        page: number;
-        limit: number;
-        total: number;
-        totalPages: number;
-        hasMore: boolean;
-    }, {
-        page: number;
-        limit: number;
-        total: number;
-        totalPages: number;
-        hasMore: boolean;
-    }>;
-}, "strip", z.ZodTypeAny, {
-    data: T["_output"][];
-    meta: {
-        page: number;
-        limit: number;
-        total: number;
-        totalPages: number;
-        hasMore: boolean;
-    };
-}, {
-    data: T["_input"][];
-    meta: {
-        page: number;
-        limit: number;
-        total: number;
-        totalPages: number;
-        hasMore: boolean;
-    };
-}>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
 /**
  * Type helper to infer paginated response type from item schema
  */
@@ -182,41 +121,14 @@ export interface PaginationMeta {
  * @param itemSchema - Zod schema for individual items
  * @returns Zod schema for cursor-paginated response
  */
-export declare function createCursorPaginatedResponseSchema<T extends z.ZodTypeAny>(itemSchema: T): z.ZodObject<{
-    /** Array of items */
-    data: z.ZodArray<T, "many">;
-    /** Cursor pagination metadata */
+export declare function createCursorPaginatedResponseSchema<T extends z.ZodType>(itemSchema: T): z.ZodObject<{
+    data: z.ZodArray<T>;
     meta: z.ZodObject<{
-        /** Cursor for the next page (null if no more) */
         nextCursor: z.ZodNullable<z.ZodString>;
-        /** Cursor for the previous page (null if at start) */
         prevCursor: z.ZodNullable<z.ZodString>;
-        /** Whether there are more items after this page */
         hasMore: z.ZodBoolean;
-    }, "strip", z.ZodTypeAny, {
-        hasMore: boolean;
-        nextCursor: string | null;
-        prevCursor: string | null;
-    }, {
-        hasMore: boolean;
-        nextCursor: string | null;
-        prevCursor: string | null;
-    }>;
-}, "strip", z.ZodTypeAny, {
-    data: T["_output"][];
-    meta: {
-        hasMore: boolean;
-        nextCursor: string | null;
-        prevCursor: string | null;
-    };
-}, {
-    data: T["_input"][];
-    meta: {
-        hasMore: boolean;
-        nextCursor: string | null;
-        prevCursor: string | null;
-    };
-}>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
 /**
  * Type for cursor-paginated response
  */

package/dist/schemas/query.d.ts

@@ -29,8 +29,8 @@ import { z } from 'zod';
  * }))
  * ```
  */
-export declare function queryNumber(): z.ZodNumber;
-export declare function queryNumber(defaultValue: number): z.ZodDefault<z.ZodNumber>;
+export declare function queryNumber(): z.ZodType<number>;
+export declare function queryNumber(defaultValue: number): z.ZodType<number>;
 /**
  * Creates an integer schema that coerces from query string
  *
@@ -45,8 +45,8 @@ export declare function queryNumber(defaultValue: number): z.ZodDefault<z.ZodNum
  * }))
  * ```
  */
-export declare function queryInt(): z.ZodNumber;
-export declare function queryInt(defaultValue: number): z.ZodDefault<z.ZodNumber>;
+export declare function queryInt(): z.ZodType<number>;
+export declare function queryInt(defaultValue: number): z.ZodType<number>;
 /**
  * Creates a boolean schema that coerces from query string
  *
@@ -117,7 +117,7 @@ export declare function queryArray(options?: {
     max?: number;
     /** Separator character (default: ',') */
     separator?: string;
-}): z.ZodType<string[], z.ZodTypeDef, string>;
+}): z.ZodType;
 /**
  * Creates an enum schema that validates against allowed values
  *
@@ -136,8 +136,12 @@ export declare function queryArray(options?: {
  * // Result: { sort: 'desc', status: 'active' }
  * ```
  */
-export declare function queryEnum<T extends readonly [string, ...string[]]>(values: T): z.ZodEnum<[T[number], ...T[number][]]>;
-export declare function queryEnum<T extends readonly [string, ...string[]]>(values: T, defaultValue: T[number]): z.ZodDefault<z.ZodEnum<[T[number], ...T[number][]]>>;
+export declare function queryEnum<const T extends readonly [string, ...string[]]>(values: T): z.ZodEnum<{
+    [K in T[number]]: K;
+}>;
+export declare function queryEnum<const T extends readonly [string, ...string[]]>(values: T, defaultValue: T[number]): z.ZodDefault<z.ZodEnum<{
+    [K in T[number]]: K;
+}>>;
 /**
  * Pre-built pagination schema for common use cases
  *
@@ -174,12 +178,6 @@ export declare function pagination(options?: {
     /** Maximum allowed items per page (default: 100) */
     maxLimit?: number;
 }): z.ZodObject<{
-    page: z.ZodDefault<z.ZodNumber>;
-    limit: z.ZodDefault<z.ZodNumber>;
-}, "strip", z.ZodTypeAny, {
-    page: number;
-    limit: number;
-}, {
-    page?: number | undefined;
-    limit?: number | undefined;
-}>;
+    page: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;

package/dist/schemas/query.js

@@ -105,10 +105,8 @@ export function queryArray(options = {}) {
     return baseSchema;
 }
 export function queryEnum(values, defaultValue) {
-    // Cast to mutable tuple type that Zod expects
-    const mutableValues = [...values];
-    const base = z.enum(mutableValues);
-    return defaultValue !== undefined ? base.default(defaultValue) : base;
+    const base = z.enum(values);
+    return (defaultValue !== undefined ? base.default(defaultValue) : base);
 }
 // ============================================================================
 // Pagination Shorthand

package/dist/schemas/serialization.d.ts

@@ -50,19 +50,19 @@ export type OmitTimestamps<T> = Omit<T, 'createdAt' | 'updatedAt' | 'deletedAt'>
  * });
  * ```
  */
-export declare function prismaDecimal(): z.ZodEffects<z.ZodAny, number, any>;
+export declare function prismaDecimal(): z.ZodPipe<z.ZodUnknown, z.ZodTransform<number, unknown>>;
 /**
  * Nullable version of prismaDecimal
  *
  * Returns null for null/undefined inputs, otherwise converts to number.
  */
-export declare function prismaDecimalNullable(): z.ZodEffects<z.ZodAny, number | null, any>;
+export declare function prismaDecimalNullable(): z.ZodPipe<z.ZodUnknown, z.ZodTransform<number | null, unknown>>;
 /**
  * Optional version of prismaDecimal
  *
  * Returns undefined for null/undefined inputs, otherwise converts to number.
  */
-export declare function prismaDecimalOptional(): z.ZodEffects<z.ZodAny, number | undefined, any>;
+export declare function prismaDecimalOptional(): z.ZodPipe<z.ZodUnknown, z.ZodTransform<number | undefined, unknown>>;
 /**
  * Creates a date field that serializes to ISO string
  *
@@ -78,15 +78,15 @@ export declare function prismaDecimalOptional(): z.ZodEffects<z.ZodAny, number |
  * });
  * ```
  */
-export declare function dateToISOString(): z.ZodEffects<z.ZodDate, string, Date>;
+export declare function dateToISOString(): z.ZodPipe<z.ZodCoercedDate<unknown>, z.ZodTransform<string, Date>>;
 /**
  * Creates a nullable date field that serializes to ISO string or null
  */
-export declare function dateToISOStringNullable(): z.ZodEffects<z.ZodNullable<z.ZodDate>, string | null, Date | null>;
+export declare function dateToISOStringNullable(): z.ZodPipe<z.ZodNullable<z.ZodCoercedDate<unknown>>, z.ZodTransform<string | null, Date | null>>;
 /**
  * Creates an optional date field that serializes to ISO string or undefined
  */
-export declare function dateToISOStringOptional(): z.ZodEffects<z.ZodOptional<z.ZodDate>, string | undefined, Date | undefined>;
+export declare function dateToISOStringOptional(): z.ZodPipe<z.ZodOptional<z.ZodCoercedDate<unknown>>, z.ZodTransform<string | undefined, Date | undefined>>;
 /**
  * Alias for dateToISOString for naming consistency
  * @alias dateToISOString
@@ -110,35 +110,21 @@ export declare const dateToIsoOptional: typeof dateToISOStringOptional;
  * const UserSchema = z.object({
  *   id: z.string().uuid(),
  *   name: z.string(),
- * }).merge(timestamps);
+ * }).extend(timestamps.shape);
  * ```
  */
 export declare const timestamps: ZodObject<{
-    createdAt: z.ZodEffects<z.ZodDate, string, Date>;
-    updatedAt: z.ZodEffects<z.ZodDate, string, Date>;
-}, "strip", z.ZodTypeAny, {
-    createdAt: string;
-    updatedAt: string;
-}, {
-    createdAt: Date;
-    updatedAt: Date;
-}>;
+    createdAt: z.ZodPipe<z.ZodCoercedDate<unknown>, z.ZodTransform<string, Date>>;
+    updatedAt: z.ZodPipe<z.ZodCoercedDate<unknown>, z.ZodTransform<string, Date>>;
+}, z.core.$strip>;
 /**
  * Timestamp fields with soft delete support
  */
 export declare const timestampsWithSoftDelete: ZodObject<{
-    createdAt: z.ZodEffects<z.ZodDate, string, Date>;
-    updatedAt: z.ZodEffects<z.ZodDate, string, Date>;
-    deletedAt: z.ZodEffects<z.ZodNullable<z.ZodDate>, string | null, Date | null>;
-}, "strip", z.ZodTypeAny, {
-    createdAt: string;
-    updatedAt: string;
-    deletedAt: string | null;
-}, {
-    createdAt: Date;
-    updatedAt: Date;
-    deletedAt: Date | null;
-}>;
+    createdAt: z.ZodPipe<z.ZodCoercedDate<unknown>, z.ZodTransform<string, Date>>;
+    updatedAt: z.ZodPipe<z.ZodCoercedDate<unknown>, z.ZodTransform<string, Date>>;
+    deletedAt: z.ZodPipe<z.ZodNullable<z.ZodCoercedDate<unknown>>, z.ZodTransform<string | null, Date | null>>;
+}, z.core.$strip>;
 /**
  * Configuration for withTimestamps
  */
@@ -177,8 +163,8 @@ interface TimestampConfig {
  */
 export declare function withTimestamps<T extends ZodRawShape>(schema: ZodObject<T>, config?: TimestampConfig): ZodObject<T & typeof timestampShape>;
 declare const timestampShape: {
-    createdAt: z.ZodEffects<z.ZodDate, string, Date>;
-    updatedAt: z.ZodEffects<z.ZodDate, string, Date>;
+    createdAt: z.ZodPipe<z.ZodCoercedDate<unknown>, z.ZodTransform<string, Date>>;
+    updatedAt: z.ZodPipe<z.ZodCoercedDate<unknown>, z.ZodTransform<string, Date>>;
 };
 /**
  * Type helper to infer the output type of a schema with timestamps

package/dist/schemas/serialization.js

@@ -26,7 +26,7 @@ import { z } from 'zod';
  * ```
  */
 export function prismaDecimal() {
-    return z.any().transform((val) => {
+    return z.unknown().transform((val) => {
         if (val === null || val === undefined) {
             throw new Error('Expected Decimal, got null/undefined');
         }
@@ -55,7 +55,7 @@ export function prismaDecimal() {
  * Returns null for null/undefined inputs, otherwise converts to number.
  */
 export function prismaDecimalNullable() {
-    return z.any().transform((val) => {
+    return z.unknown().transform((val) => {
         if (val === null || val === undefined) {
             return null;
         }
@@ -81,7 +81,7 @@ export function prismaDecimalNullable() {
  * Returns undefined for null/undefined inputs, otherwise converts to number.
  */
 export function prismaDecimalOptional() {
-    return z.any().transform((val) => {
+    return z.unknown().transform((val) => {
         if (val === null || val === undefined) {
             return undefined;
         }
@@ -166,7 +166,7 @@ export const dateToIsoOptional = dateToISOStringOptional;
  * const UserSchema = z.object({
  *   id: z.string().uuid(),
  *   name: z.string(),
- * }).merge(timestamps);
+ * }).extend(timestamps.shape);
  * ```
  */
 export const timestamps = z.object({

package/dist/types.d.ts

@@ -6,7 +6,7 @@
  *
  * @module types
  */
-import type { ZodType, ZodTypeDef } from 'zod';
+import type { ZodType } from 'zod';
 /**
  * Type-safe validator interface that wraps Zod schemas
  *
@@ -77,7 +77,9 @@ export interface ValidationIssue {
  * // User = { id: string; name: string }
  * ```
  */
-export type InferOutput<T> = T extends Schema<infer O, infer _I> ? O : T extends ZodType<infer O, ZodTypeDef, infer _I> ? O : never;
+export type InferOutput<T> = T extends Schema<infer O, infer _I> ? O : T extends {
+    parse: (data: unknown) => infer O;
+} ? O : never;
 /**
  * Infers the input type from a Schema or ZodType
  *
@@ -92,13 +94,17 @@ export type InferOutput<T> = T extends Schema<infer O, infer _I> ? O : T extends
  * // DateInput = string (not Date)
  * ```
  */
-export type InferInput<T> = T extends Schema<infer _O, infer I> ? I : T extends ZodType<infer _O, ZodTypeDef, infer I> ? I : never;
+export type InferInput<T> = T extends Schema<infer _O, infer I> ? I : T extends {
+    _input: infer I;
+} ? I : T extends {
+    '~input': infer I;
+} ? I : never;
 /**
  * Type constraint for any Zod schema
  *
  * Used in generic constraints to accept any valid Zod schema.
  */
-export type AnyZodSchema = ZodType<unknown, ZodTypeDef, unknown>;
+export type AnyZodSchema = ZodType;
 /**
  * Type constraint for any Schema wrapper
  */
@@ -137,7 +143,9 @@ export declare function isZodSchema(value: unknown): value is AnyZodSchema;
  * }));
  * ```
  */
-export declare function wrapSchema<TOutput, TInput = TOutput>(zodSchema: ZodType<TOutput, ZodTypeDef, TInput>): Schema<TOutput, TInput>;
+export declare function wrapSchema<TOutput, TInput = TOutput>(zodSchema: ZodType & {
+    parse: (input: unknown) => TOutput;
+}): Schema<TOutput, TInput>;
 /**
  * Represents no input (undefined) for procedures without input schemas
  */

package/dist/types.js

@@ -23,7 +23,7 @@ export function isZodSchema(value) {
         value !== null &&
         'parse' in value &&
         'safeParse' in value &&
-        '_def' in value);
+        ('_zod' in value || '_def' in value));
 }
 // ============================================================================
 // Schema Wrapper Factory

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@veloxts/validation",
-  "version": "0.6.102",
+  "version": "0.6.104",
   "description": "Zod integration and validation middleware for VeloxTS framework",
   "type": "module",
   "main": "dist/index.js",
@@ -22,8 +22,8 @@
     }
   },
   "dependencies": {
-    "zod": "3.25.76",
-    "@veloxts/core": "0.6.102"
+    "zod": "4.3.6",
+    "@veloxts/core": "0.6.104"
   },
   "devDependencies": {
     "@vitest/coverage-v8": "4.0.18",
@@ -31,7 +31,7 @@
     "vitest": "4.0.18"
   },
   "peerDependencies": {
-    "zod": "^3.25.0"
+    "zod": "^4.3.0"
   },
   "peerDependenciesMeta": {
     "zod": {