unischema 1.1.0 → 1.2.0

package/dist/{chunk-FZ7K2PC7.js → chunk-TXT36BCE.js}

@@ -1,19 +1,19 @@
 'use strict';
 
-var chunkNUW55QTO_js = require('./chunk-NUW55QTO.js');
+var chunkOIYG5D2I_js = require('./chunk-OIYG5D2I.js');
 
 // src/validators/date/today.ts
 var todayValidator = (value, params, context) => {
-  if (chunkNUW55QTO_js.isEmpty(value)) return null;
+  if (chunkOIYG5D2I_js.isEmpty(value)) return null;
   const soft = params?.soft;
   const message = params?.message;
-  const date = chunkNUW55QTO_js.parseDate(value);
+  const date = chunkOIYG5D2I_js.parseDate(value);
   if (!date) return null;
   const today = /* @__PURE__ */ new Date();
   today.setHours(0, 0, 0, 0);
   date.setHours(0, 0, 0, 0);
   if (date.getTime() !== today.getTime()) {
-    return chunkNUW55QTO_js.createError(
+    return chunkOIYG5D2I_js.createError(
       context,
       "INVALID_TODAY",
       message || "Date must be today",
@@ -25,17 +25,17 @@ var todayValidator = (value, params, context) => {
 
 // src/validators/date/yesterday.ts
 var yesterdayValidator = (value, params, context) => {
-  if (chunkNUW55QTO_js.isEmpty(value)) return null;
+  if (chunkOIYG5D2I_js.isEmpty(value)) return null;
   const soft = params?.soft;
   const message = params?.message;
-  const date = chunkNUW55QTO_js.parseDate(value);
+  const date = chunkOIYG5D2I_js.parseDate(value);
   if (!date) return null;
   const yesterday = /* @__PURE__ */ new Date();
   yesterday.setDate(yesterday.getDate() - 1);
   yesterday.setHours(0, 0, 0, 0);
   date.setHours(0, 0, 0, 0);
   if (date.getTime() !== yesterday.getTime()) {
-    return chunkNUW55QTO_js.createError(
+    return chunkOIYG5D2I_js.createError(
       context,
       "INVALID_YESTERDAY",
       message || "Date must be yesterday",
@@ -47,17 +47,17 @@ var yesterdayValidator = (value, params, context) => {
 
 // src/validators/date/tomorrow.ts
 var tomorrowValidator = (value, params, context) => {
-  if (chunkNUW55QTO_js.isEmpty(value)) return null;
+  if (chunkOIYG5D2I_js.isEmpty(value)) return null;
   const soft = params?.soft;
   const message = params?.message;
-  const date = chunkNUW55QTO_js.parseDate(value);
+  const date = chunkOIYG5D2I_js.parseDate(value);
   if (!date) return null;
   const tomorrow = /* @__PURE__ */ new Date();
   tomorrow.setDate(tomorrow.getDate() + 1);
   tomorrow.setHours(0, 0, 0, 0);
   date.setHours(0, 0, 0, 0);
   if (date.getTime() !== tomorrow.getTime()) {
-    return chunkNUW55QTO_js.createError(
+    return chunkOIYG5D2I_js.createError(
       context,
       "INVALID_TOMORROW",
       message || "Date must be tomorrow",
@@ -69,10 +69,10 @@ var tomorrowValidator = (value, params, context) => {
 
 // src/validators/date/thisWeek.ts
 var thisWeekValidator = (value, params, context) => {
-  if (chunkNUW55QTO_js.isEmpty(value)) return null;
+  if (chunkOIYG5D2I_js.isEmpty(value)) return null;
   const soft = params?.soft;
   const message = params?.message;
-  const date = chunkNUW55QTO_js.parseDate(value);
+  const date = chunkOIYG5D2I_js.parseDate(value);
   if (!date) return null;
   const now = /* @__PURE__ */ new Date();
   const startOfWeek = new Date(now);
@@ -82,7 +82,7 @@ var thisWeekValidator = (value, params, context) => {
   endOfWeek.setDate(startOfWeek.getDate() + 6);
   endOfWeek.setHours(23, 59, 59, 999);
   if (date < startOfWeek || date > endOfWeek) {
-    return chunkNUW55QTO_js.createError(
+    return chunkOIYG5D2I_js.createError(
       context,
       "INVALID_THIS_WEEK",
       message || "Date must be within this week",
@@ -94,16 +94,16 @@ var thisWeekValidator = (value, params, context) => {
 
 // src/validators/date/thisMonth.ts
 var thisMonthValidator = (value, params, context) => {
-  if (chunkNUW55QTO_js.isEmpty(value)) return null;
+  if (chunkOIYG5D2I_js.isEmpty(value)) return null;
   const soft = params?.soft;
   const message = params?.message;
-  const date = chunkNUW55QTO_js.parseDate(value);
+  const date = chunkOIYG5D2I_js.parseDate(value);
   if (!date) return null;
   const now = /* @__PURE__ */ new Date();
   const startOfMonth = new Date(now.getFullYear(), now.getMonth(), 1);
   const endOfMonth = new Date(now.getFullYear(), now.getMonth() + 1, 0, 23, 59, 59, 999);
   if (date < startOfMonth || date > endOfMonth) {
-    return chunkNUW55QTO_js.createError(
+    return chunkOIYG5D2I_js.createError(
       context,
       "INVALID_THIS_MONTH",
       message || "Date must be within this month",
@@ -115,16 +115,16 @@ var thisMonthValidator = (value, params, context) => {
 
 // src/validators/date/thisYear.ts
 var thisYearValidator = (value, params, context) => {
-  if (chunkNUW55QTO_js.isEmpty(value)) return null;
+  if (chunkOIYG5D2I_js.isEmpty(value)) return null;
   const soft = params?.soft;
   const message = params?.message;
-  const date = chunkNUW55QTO_js.parseDate(value);
+  const date = chunkOIYG5D2I_js.parseDate(value);
   if (!date) return null;
   const now = /* @__PURE__ */ new Date();
   const startOfYear = new Date(now.getFullYear(), 0, 1);
   const endOfYear = new Date(now.getFullYear(), 11, 31, 23, 59, 59, 999);
   if (date < startOfYear || date > endOfYear) {
-    return chunkNUW55QTO_js.createError(
+    return chunkOIYG5D2I_js.createError(
       context,
       "INVALID_THIS_YEAR",
       message || "Date must be within this year",
@@ -136,14 +136,14 @@ var thisYearValidator = (value, params, context) => {
 
 // src/validators/date/weekday.ts
 var weekdayValidator = (value, params, context) => {
-  if (chunkNUW55QTO_js.isEmpty(value)) return null;
+  if (chunkOIYG5D2I_js.isEmpty(value)) return null;
   const soft = params?.soft;
   const message = params?.message;
-  const date = chunkNUW55QTO_js.parseDate(value);
+  const date = chunkOIYG5D2I_js.parseDate(value);
   if (!date) return null;
   const day = date.getDay();
   if (day === 0 || day === 6) {
-    return chunkNUW55QTO_js.createError(
+    return chunkOIYG5D2I_js.createError(
       context,
       "INVALID_WEEKDAY",
       message || "Date must be a weekday",
@@ -155,14 +155,14 @@ var weekdayValidator = (value, params, context) => {
 
 // src/validators/date/weekend.ts
 var weekendValidator = (value, params, context) => {
-  if (chunkNUW55QTO_js.isEmpty(value)) return null;
+  if (chunkOIYG5D2I_js.isEmpty(value)) return null;
   const soft = params?.soft;
   const message = params?.message;
-  const date = chunkNUW55QTO_js.parseDate(value);
+  const date = chunkOIYG5D2I_js.parseDate(value);
   if (!date) return null;
   const day = date.getDay();
   if (day !== 0 && day !== 6) {
-    return chunkNUW55QTO_js.createError(
+    return chunkOIYG5D2I_js.createError(
       context,
       "INVALID_WEEKEND",
       message || "Date must be a weekend",
@@ -174,12 +174,12 @@ var weekendValidator = (value, params, context) => {
 
 // src/validators/date/age.ts
 var ageValidator = (value, params, context) => {
-  if (chunkNUW55QTO_js.isEmpty(value)) return null;
+  if (chunkOIYG5D2I_js.isEmpty(value)) return null;
   const min = params?.min;
   const max = params?.max;
   const soft = params?.soft;
   const message = params?.message;
-  const birthDate = chunkNUW55QTO_js.parseDate(value);
+  const birthDate = chunkOIYG5D2I_js.parseDate(value);
   if (!birthDate) return null;
   const today = /* @__PURE__ */ new Date();
   let age = today.getFullYear() - birthDate.getFullYear();
@@ -188,7 +188,7 @@ var ageValidator = (value, params, context) => {
     age--;
   }
   if (min !== void 0 && age < min) {
-    return chunkNUW55QTO_js.createError(
+    return chunkOIYG5D2I_js.createError(
       context,
       "INVALID_AGE_MIN",
       message || `Age must be at least ${min}`,
@@ -196,7 +196,7 @@ var ageValidator = (value, params, context) => {
     );
   }
   if (max !== void 0 && age > max) {
-    return chunkNUW55QTO_js.createError(
+    return chunkOIYG5D2I_js.createError(
       context,
       "INVALID_AGE_MAX",
       message || `Age must be at most ${max}`,
@@ -208,17 +208,17 @@ var ageValidator = (value, params, context) => {
 
 // src/validators/date/between.ts
 var betweenValidator = (value, params, context) => {
-  if (chunkNUW55QTO_js.isEmpty(value)) return null;
+  if (chunkOIYG5D2I_js.isEmpty(value)) return null;
   const start = params?.start;
   const end = params?.end;
   const soft = params?.soft;
   const message = params?.message;
-  const date = chunkNUW55QTO_js.parseDate(value);
+  const date = chunkOIYG5D2I_js.parseDate(value);
   if (!date) return null;
-  const startDate = chunkNUW55QTO_js.parseDate(start);
-  const endDate = chunkNUW55QTO_js.parseDate(end);
+  const startDate = chunkOIYG5D2I_js.parseDate(start);
+  const endDate = chunkOIYG5D2I_js.parseDate(end);
   if (startDate && date < startDate) {
-    return chunkNUW55QTO_js.createError(
+    return chunkOIYG5D2I_js.createError(
       context,
       "INVALID_DATE_BEFORE",
       message || `Date must be after ${startDate.toLocaleDateString()}`,
@@ -226,7 +226,7 @@ var betweenValidator = (value, params, context) => {
     );
   }
   if (endDate && date > endDate) {
-    return chunkNUW55QTO_js.createError(
+    return chunkOIYG5D2I_js.createError(
       context,
       "INVALID_DATE_AFTER",
       message || `Date must be before ${endDate.toLocaleDateString()}`,

package/dist/index-C17xs-fU.d.mts

@@ -0,0 +1,140 @@
+/**
+ * Core types for the FormSchema validation engine
+ */
+type ValidationSeverity = 'hard' | 'soft';
+interface ValidationError {
+    /** Field path (e.g., "email" or "address.city") */
+    field: string;
+    /** Path as array (e.g., ["address", "city"]) */
+    path?: string[];
+    /** Error code for programmatic handling */
+    code: string;
+    /** Human-readable error message */
+    message: string;
+    /** Severity level - hard errors block submission, soft are warnings */
+    severity: ValidationSeverity;
+    /** Value that was received (for context) */
+    received?: unknown;
+    /** Expected value or constraints (for context) */
+    expected?: unknown;
+}
+interface ValidationResult {
+    /** True if no hard errors exist */
+    valid: boolean;
+    /** Errors that block form submission */
+    hardErrors: ValidationError[];
+    /** Warnings that don't block submission */
+    softErrors: ValidationError[];
+    /** Errors aggregated by field path */
+    errorsByField?: Record<string, ValidationError[]>;
+}
+/** Validation options */
+interface ValidationOptions {
+    /** Custom error message formatter */
+    errorMap?: (error: ValidationError) => ValidationError | {
+        message: string;
+    };
+    /** Stop validation on first error */
+    abortEarly?: boolean;
+    /** Aggregate errors by field */
+    aggregateByField?: boolean;
+}
+type FieldType = 'string' | 'number' | 'boolean' | 'date' | 'array' | 'object';
+interface ValidationRule {
+    /** Rule type identifier */
+    type: string;
+    /** Rule parameters */
+    params?: Record<string, unknown>;
+    /** Custom error message */
+    message?: string;
+    /** Is this a soft validation (warning only)? */
+    soft?: boolean;
+    /** Is this an async validation? */
+    async?: boolean;
+    /** Debounce delay in ms for async validators */
+    debounce?: number;
+    /** Timeout in ms for async validators */
+    timeout?: number;
+}
+interface FieldDefinition<T = unknown> {
+    /** The base type of this field */
+    type: FieldType;
+    /** Validation rules to apply */
+    rules: ValidationRule[];
+    /** Is this field required? */
+    required: boolean;
+    /** Default value */
+    defaultValue?: T;
+    /** For nested schemas */
+    schema?: SchemaDefinition;
+    /** For array items */
+    items?: FieldDefinition;
+    /** Field metadata */
+    meta?: Record<string, unknown>;
+    /** Transform functions to apply to value */
+    transforms?: Array<(value: unknown) => unknown>;
+    /** Preprocess function to apply before validation */
+    preprocess?: (value: unknown) => unknown;
+    /** Allow null values */
+    nullable?: boolean;
+    /** Allow null or undefined values */
+    nullish?: boolean;
+}
+interface SchemaDefinition {
+    /** Field definitions keyed by field name */
+    fields: Record<string, FieldDefinition>;
+    /** Schema metadata */
+    meta?: Record<string, unknown>;
+    /** Allow unknown keys to pass through */
+    passthrough?: boolean;
+    /** Strict mode - reject unknown keys */
+    strict?: boolean;
+    /** Catchall field definition for unknown keys */
+    catchall?: FieldDefinition;
+}
+interface ValidatorContext {
+    /** Current field path */
+    path: string;
+    /** Full data object being validated */
+    root: unknown;
+    /** Parent object containing this field */
+    parent?: unknown;
+}
+type ValidatorFn = (value: unknown, params: Record<string, unknown> | undefined, context: ValidatorContext) => ValidationError | null;
+type AsyncValidatorFn = (value: unknown, params: Record<string, unknown> | undefined, context: ValidatorContext) => Promise<ValidationError | null>;
+/** Async refine function type - returns boolean or validation result object */
+type AsyncRefineFn<T = unknown> = (value: T) => Promise<boolean | {
+    valid: boolean;
+    message?: string;
+}>;
+/** Options for async validation */
+interface AsyncValidationOptions {
+    /** Custom error message */
+    message?: string;
+    /** Debounce delay in ms */
+    debounce?: number;
+    /** Timeout in ms (default: 5000) */
+    timeout?: number;
+    /** Is this a soft validation (warning only)? */
+    soft?: boolean;
+    /** Cache results (useful for expensive checks) */
+    cache?: boolean;
+    /** Cache TTL in seconds (default: 3600) */
+    cacheTTL?: number;
+}
+interface EnterpriseValidationResponse {
+    status: 'success' | 'validation_error';
+    data?: unknown;
+    errors: ValidationError[];
+    msg: string;
+    validation: {
+        hard_validations: ValidationError[];
+        soft_validations: ValidationError[];
+    };
+}
+/**
+ * Convert ValidationResult to enterprise-compatible response format
+ */
+declare function toEnterpriseResponse(result: ValidationResult, data?: unknown): EnterpriseValidationResponse;
+
+export { type AsyncRefineFn as A, type EnterpriseValidationResponse as E, type FieldDefinition as F, type SchemaDefinition as S, type ValidatorContext as V, type ValidationError as a, type ValidationResult as b, type ValidationRule as c, type AsyncValidationOptions as d, type ValidationOptions as e, type ValidatorFn as f, type ValidationSeverity as g, type FieldType as h, type AsyncValidatorFn as i, toEnterpriseResponse as t };

package/dist/index-C17xs-fU.d.ts

@@ -0,0 +1,140 @@
+/**
+ * Core types for the FormSchema validation engine
+ */
+type ValidationSeverity = 'hard' | 'soft';
+interface ValidationError {
+    /** Field path (e.g., "email" or "address.city") */
+    field: string;
+    /** Path as array (e.g., ["address", "city"]) */
+    path?: string[];
+    /** Error code for programmatic handling */
+    code: string;
+    /** Human-readable error message */
+    message: string;
+    /** Severity level - hard errors block submission, soft are warnings */
+    severity: ValidationSeverity;
+    /** Value that was received (for context) */
+    received?: unknown;
+    /** Expected value or constraints (for context) */
+    expected?: unknown;
+}
+interface ValidationResult {
+    /** True if no hard errors exist */
+    valid: boolean;
+    /** Errors that block form submission */
+    hardErrors: ValidationError[];
+    /** Warnings that don't block submission */
+    softErrors: ValidationError[];
+    /** Errors aggregated by field path */
+    errorsByField?: Record<string, ValidationError[]>;
+}
+/** Validation options */
+interface ValidationOptions {
+    /** Custom error message formatter */
+    errorMap?: (error: ValidationError) => ValidationError | {
+        message: string;
+    };
+    /** Stop validation on first error */
+    abortEarly?: boolean;
+    /** Aggregate errors by field */
+    aggregateByField?: boolean;
+}
+type FieldType = 'string' | 'number' | 'boolean' | 'date' | 'array' | 'object';
+interface ValidationRule {
+    /** Rule type identifier */
+    type: string;
+    /** Rule parameters */
+    params?: Record<string, unknown>;
+    /** Custom error message */
+    message?: string;
+    /** Is this a soft validation (warning only)? */
+    soft?: boolean;
+    /** Is this an async validation? */
+    async?: boolean;
+    /** Debounce delay in ms for async validators */
+    debounce?: number;
+    /** Timeout in ms for async validators */
+    timeout?: number;
+}
+interface FieldDefinition<T = unknown> {
+    /** The base type of this field */
+    type: FieldType;
+    /** Validation rules to apply */
+    rules: ValidationRule[];
+    /** Is this field required? */
+    required: boolean;
+    /** Default value */
+    defaultValue?: T;
+    /** For nested schemas */
+    schema?: SchemaDefinition;
+    /** For array items */
+    items?: FieldDefinition;
+    /** Field metadata */
+    meta?: Record<string, unknown>;
+    /** Transform functions to apply to value */
+    transforms?: Array<(value: unknown) => unknown>;
+    /** Preprocess function to apply before validation */
+    preprocess?: (value: unknown) => unknown;
+    /** Allow null values */
+    nullable?: boolean;
+    /** Allow null or undefined values */
+    nullish?: boolean;
+}
+interface SchemaDefinition {
+    /** Field definitions keyed by field name */
+    fields: Record<string, FieldDefinition>;
+    /** Schema metadata */
+    meta?: Record<string, unknown>;
+    /** Allow unknown keys to pass through */
+    passthrough?: boolean;
+    /** Strict mode - reject unknown keys */
+    strict?: boolean;
+    /** Catchall field definition for unknown keys */
+    catchall?: FieldDefinition;
+}
+interface ValidatorContext {
+    /** Current field path */
+    path: string;
+    /** Full data object being validated */
+    root: unknown;
+    /** Parent object containing this field */
+    parent?: unknown;
+}
+type ValidatorFn = (value: unknown, params: Record<string, unknown> | undefined, context: ValidatorContext) => ValidationError | null;
+type AsyncValidatorFn = (value: unknown, params: Record<string, unknown> | undefined, context: ValidatorContext) => Promise<ValidationError | null>;
+/** Async refine function type - returns boolean or validation result object */
+type AsyncRefineFn<T = unknown> = (value: T) => Promise<boolean | {
+    valid: boolean;
+    message?: string;
+}>;
+/** Options for async validation */
+interface AsyncValidationOptions {
+    /** Custom error message */
+    message?: string;
+    /** Debounce delay in ms */
+    debounce?: number;
+    /** Timeout in ms (default: 5000) */
+    timeout?: number;
+    /** Is this a soft validation (warning only)? */
+    soft?: boolean;
+    /** Cache results (useful for expensive checks) */
+    cache?: boolean;
+    /** Cache TTL in seconds (default: 3600) */
+    cacheTTL?: number;
+}
+interface EnterpriseValidationResponse {
+    status: 'success' | 'validation_error';
+    data?: unknown;
+    errors: ValidationError[];
+    msg: string;
+    validation: {
+        hard_validations: ValidationError[];
+        soft_validations: ValidationError[];
+    };
+}
+/**
+ * Convert ValidationResult to enterprise-compatible response format
+ */
+declare function toEnterpriseResponse(result: ValidationResult, data?: unknown): EnterpriseValidationResponse;
+
+export { type AsyncRefineFn as A, type EnterpriseValidationResponse as E, type FieldDefinition as F, type SchemaDefinition as S, type ValidatorContext as V, type ValidationError as a, type ValidationResult as b, type ValidationRule as c, type AsyncValidationOptions as d, type ValidationOptions as e, type ValidatorFn as f, type ValidationSeverity as g, type FieldType as h, type AsyncValidatorFn as i, toEnterpriseResponse as t };

package/dist/index.d.mts

@@ -1,6 +1,6 @@
-import { S as SchemaDefinition, b as ValidationResult, c as ValidatorFn } from './index-BQR7OrY7.mjs';
-export { E as EnterpriseValidationResponse, f as FieldDefinition, F as FieldType, a as ValidationError, e as ValidationRule, d as ValidationSeverity, V as ValidatorContext, t as toEnterpriseResponse } from './index-BQR7OrY7.mjs';
-export { A as ArrayFieldBuilder, B as BaseFieldBuilder, d as BooleanFieldBuilder, D as DateFieldBuilder, E as EnumFieldBuilder, I as InferInput, b as InferOutput, N as NumberFieldBuilder, O as ObjectFieldBuilder, S as SchemaBuilder, c as StringFieldBuilder, e as extend, f as field, m as merge, o as omit, a as partial, p as pick, s as schema } from './schema-DYU1zGVm.mjs';
+import { S as SchemaDefinition, e as ValidationOptions, b as ValidationResult, f as ValidatorFn } from './index-C17xs-fU.mjs';
+export { A as AsyncRefineFn, d as AsyncValidationOptions, i as AsyncValidatorFn, E as EnterpriseValidationResponse, F as FieldDefinition, h as FieldType, a as ValidationError, c as ValidationRule, g as ValidationSeverity, V as ValidatorContext, t as toEnterpriseResponse } from './index-C17xs-fU.mjs';
+export { A as ArrayFieldBuilder, B as BaseFieldBuilder, l as BooleanFieldBuilder, n as DateFieldBuilder, D as DeepPartial, E as EnumFieldBuilder, I as InferInput, j as InferOutput, N as NumberFieldBuilder, O as ObjectFieldBuilder, S as SchemaBuilder, k as StringFieldBuilder, f as catchall, i as coerce, d as deepPartial, e as extend, h as field, m as merge, o as omit, g as optional, a as partial, b as passthrough, p as pick, r as required, s as schema, c as strict } from './schema-DYE8Wz8X.mjs';
 
 /**
  * Core validation engine - runs unchanged in browser and Node.js
@@ -9,19 +9,19 @@ export { A as ArrayFieldBuilder, B as BaseFieldBuilder, d as BooleanFieldBuilder
 /**
  * Validate data against a schema
  */
-declare function validateSchema(schema: SchemaDefinition, data: Record<string, unknown>, basePath?: string, root?: unknown): ValidationResult;
+declare function validateSchema(schema: SchemaDefinition, data: Record<string, unknown>, basePath?: string, root?: unknown, options?: ValidationOptions): ValidationResult;
 /**
  * Main validation function
  */
-declare function validate<T extends Record<string, unknown>>(schema: SchemaDefinition, data: T): ValidationResult;
+declare function validate<T extends Record<string, unknown>>(schema: SchemaDefinition, data: T, options?: ValidationOptions): ValidationResult;
 /**
  * Check if data is valid (no hard errors)
  */
-declare function isValid(schema: SchemaDefinition, data: Record<string, unknown>): boolean;
+declare function isValid(schema: SchemaDefinition, data: Record<string, unknown>, options?: ValidationOptions): boolean;
 /**
  * Validate and throw if invalid
  */
-declare function assertValid<T extends Record<string, unknown>>(schema: SchemaDefinition, data: T): T;
+declare function assertValid<T extends Record<string, unknown>>(schema: SchemaDefinition, data: T, options?: ValidationOptions): T;
 /**
  * Merge multiple validation results
  */
@@ -35,6 +35,24 @@ declare function validResult(): ValidationResult;
  */
 declare function errorResult(field: string, code: string, message: string, soft?: boolean): ValidationResult;
 
+/**
+ * Async validation engine for handling asynchronous validators
+ */
+
+declare function validateSchemaAsync(schema: SchemaDefinition, data: Record<string, unknown>, basePath?: string, root?: unknown): Promise<ValidationResult>;
+/**
+ * Main async validation function
+ */
+declare function validateAsync<T extends Record<string, unknown>>(schema: SchemaDefinition, data: T): Promise<ValidationResult>;
+/**
+ * Check if data is valid async (no hard errors)
+ */
+declare function isValidAsync(schema: SchemaDefinition, data: Record<string, unknown>): Promise<boolean>;
+/**
+ * Validate async and throw if invalid
+ */
+declare function assertValidAsync<T extends Record<string, unknown>>(schema: SchemaDefinition, data: T): Promise<T>;
+
 /**
  * Built-in validators for common validation rules
  */
@@ -54,4 +72,4 @@ declare function getValidator(name: string): ValidatorFn | undefined;
  */
 declare function getTypeValidator(type: string): ValidatorFn | undefined;
 
-export { SchemaDefinition, ValidationResult, ValidatorFn, assertValid, errorResult, getTypeValidator, getValidator, isValid, mergeResults, registerValidator, ruleValidators, typeValidators, validResult, validate, validateSchema };
+export { SchemaDefinition, ValidationOptions, ValidationResult, ValidatorFn, assertValid, assertValidAsync, errorResult, getTypeValidator, getValidator, isValid, isValidAsync, mergeResults, registerValidator, ruleValidators, typeValidators, validResult, validate, validateAsync, validateSchema, validateSchemaAsync };

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-import { S as SchemaDefinition, b as ValidationResult, c as ValidatorFn } from './index-BQR7OrY7.js';
-export { E as EnterpriseValidationResponse, f as FieldDefinition, F as FieldType, a as ValidationError, e as ValidationRule, d as ValidationSeverity, V as ValidatorContext, t as toEnterpriseResponse } from './index-BQR7OrY7.js';
-export { A as ArrayFieldBuilder, B as BaseFieldBuilder, d as BooleanFieldBuilder, D as DateFieldBuilder, E as EnumFieldBuilder, I as InferInput, b as InferOutput, N as NumberFieldBuilder, O as ObjectFieldBuilder, S as SchemaBuilder, c as StringFieldBuilder, e as extend, f as field, m as merge, o as omit, a as partial, p as pick, s as schema } from './schema-CpAjXgEF.js';
+import { S as SchemaDefinition, e as ValidationOptions, b as ValidationResult, f as ValidatorFn } from './index-C17xs-fU.js';
+export { A as AsyncRefineFn, d as AsyncValidationOptions, i as AsyncValidatorFn, E as EnterpriseValidationResponse, F as FieldDefinition, h as FieldType, a as ValidationError, c as ValidationRule, g as ValidationSeverity, V as ValidatorContext, t as toEnterpriseResponse } from './index-C17xs-fU.js';
+export { A as ArrayFieldBuilder, B as BaseFieldBuilder, l as BooleanFieldBuilder, n as DateFieldBuilder, D as DeepPartial, E as EnumFieldBuilder, I as InferInput, j as InferOutput, N as NumberFieldBuilder, O as ObjectFieldBuilder, S as SchemaBuilder, k as StringFieldBuilder, f as catchall, i as coerce, d as deepPartial, e as extend, h as field, m as merge, o as omit, g as optional, a as partial, b as passthrough, p as pick, r as required, s as schema, c as strict } from './schema-Dtp-joeT.js';
 
 /**
  * Core validation engine - runs unchanged in browser and Node.js
@@ -9,19 +9,19 @@ export { A as ArrayFieldBuilder, B as BaseFieldBuilder, d as BooleanFieldBuilder
 /**
  * Validate data against a schema
  */
-declare function validateSchema(schema: SchemaDefinition, data: Record<string, unknown>, basePath?: string, root?: unknown): ValidationResult;
+declare function validateSchema(schema: SchemaDefinition, data: Record<string, unknown>, basePath?: string, root?: unknown, options?: ValidationOptions): ValidationResult;
 /**
  * Main validation function
  */
-declare function validate<T extends Record<string, unknown>>(schema: SchemaDefinition, data: T): ValidationResult;
+declare function validate<T extends Record<string, unknown>>(schema: SchemaDefinition, data: T, options?: ValidationOptions): ValidationResult;
 /**
  * Check if data is valid (no hard errors)
  */
-declare function isValid(schema: SchemaDefinition, data: Record<string, unknown>): boolean;
+declare function isValid(schema: SchemaDefinition, data: Record<string, unknown>, options?: ValidationOptions): boolean;
 /**
  * Validate and throw if invalid
  */
-declare function assertValid<T extends Record<string, unknown>>(schema: SchemaDefinition, data: T): T;
+declare function assertValid<T extends Record<string, unknown>>(schema: SchemaDefinition, data: T, options?: ValidationOptions): T;
 /**
  * Merge multiple validation results
  */
@@ -35,6 +35,24 @@ declare function validResult(): ValidationResult;
  */
 declare function errorResult(field: string, code: string, message: string, soft?: boolean): ValidationResult;
 
+/**
+ * Async validation engine for handling asynchronous validators
+ */
+
+declare function validateSchemaAsync(schema: SchemaDefinition, data: Record<string, unknown>, basePath?: string, root?: unknown): Promise<ValidationResult>;
+/**
+ * Main async validation function
+ */
+declare function validateAsync<T extends Record<string, unknown>>(schema: SchemaDefinition, data: T): Promise<ValidationResult>;
+/**
+ * Check if data is valid async (no hard errors)
+ */
+declare function isValidAsync(schema: SchemaDefinition, data: Record<string, unknown>): Promise<boolean>;
+/**
+ * Validate async and throw if invalid
+ */
+declare function assertValidAsync<T extends Record<string, unknown>>(schema: SchemaDefinition, data: T): Promise<T>;
+
 /**
  * Built-in validators for common validation rules
  */
@@ -54,4 +72,4 @@ declare function getValidator(name: string): ValidatorFn | undefined;
  */
 declare function getTypeValidator(type: string): ValidatorFn | undefined;
 
-export { SchemaDefinition, ValidationResult, ValidatorFn, assertValid, errorResult, getTypeValidator, getValidator, isValid, mergeResults, registerValidator, ruleValidators, typeValidators, validResult, validate, validateSchema };
+export { SchemaDefinition, ValidationOptions, ValidationResult, ValidatorFn, assertValid, assertValidAsync, errorResult, getTypeValidator, getValidator, isValid, isValidAsync, mergeResults, registerValidator, ruleValidators, typeValidators, validResult, validate, validateAsync, validateSchema, validateSchemaAsync };