unischema 1.0.1 → 1.2.0

package/dist/index.js

@@ -1,470 +1,14 @@
 'use strict';
 
-// src/core/validators.ts
-function createError(context, code, message, soft = false) {
-  return {
-    field: context.path,
-    code,
-    message,
-    severity: soft ? "soft" : "hard"
-  };
-}
-var typeValidators = {
-  string: (value, _params, context) => {
-    if (value !== void 0 && value !== null && typeof value !== "string") {
-      return createError(context, "INVALID_TYPE", `Expected string, got ${typeof value}`);
-    }
-    return null;
-  },
-  number: (value, _params, context) => {
-    if (value !== void 0 && value !== null && typeof value !== "number") {
-      return createError(context, "INVALID_TYPE", `Expected number, got ${typeof value}`);
-    }
-    if (typeof value === "number" && isNaN(value)) {
-      return createError(context, "INVALID_NUMBER", "Value is not a valid number");
-    }
-    return null;
-  },
-  boolean: (value, _params, context) => {
-    if (value !== void 0 && value !== null && typeof value !== "boolean") {
-      return createError(context, "INVALID_TYPE", `Expected boolean, got ${typeof value}`);
-    }
-    return null;
-  },
-  date: (value, _params, context) => {
-    if (value === void 0 || value === null) return null;
-    if (value instanceof Date) {
-      if (isNaN(value.getTime())) {
-        return createError(context, "INVALID_DATE", "Invalid date value");
-      }
-      return null;
-    }
-    if (typeof value === "string") {
-      const parsed = new Date(value);
-      if (isNaN(parsed.getTime())) {
-        return createError(context, "INVALID_DATE", "Invalid date format");
-      }
-      return null;
-    }
-    return createError(context, "INVALID_TYPE", `Expected date, got ${typeof value}`);
-  },
-  array: (value, _params, context) => {
-    if (value !== void 0 && value !== null && !Array.isArray(value)) {
-      return createError(context, "INVALID_TYPE", `Expected array, got ${typeof value}`);
-    }
-    return null;
-  },
-  object: (value, _params, context) => {
-    if (value !== void 0 && value !== null) {
-      if (typeof value !== "object" || Array.isArray(value)) {
-        return createError(context, "INVALID_TYPE", `Expected object, got ${typeof value}`);
-      }
-    }
-    return null;
-  }
-};
-var ruleValidators = {
-  required: (value, _params, context) => {
-    const isEmpty = value === void 0 || value === null || value === "" || Array.isArray(value) && value.length === 0;
-    if (isEmpty) {
-      return createError(context, "REQUIRED", "This field is required");
-    }
-    return null;
-  },
-  min: (value, params, context) => {
-    const min = params?.value;
-    const soft = params?.soft;
-    const message = params?.message;
-    if (value === void 0 || value === null) return null;
-    if (typeof value === "number") {
-      if (value < min) {
-        return createError(
-          context,
-          "MIN_VALUE",
-          message || `Value must be at least ${min}`,
-          soft
-        );
-      }
-    }
-    if (typeof value === "string") {
-      if (value.length < min) {
-        return createError(
-          context,
-          "MIN_LENGTH",
-          message || `Must be at least ${min} characters`,
-          soft
-        );
-      }
-    }
-    if (Array.isArray(value)) {
-      if (value.length < min) {
-        return createError(
-          context,
-          "MIN_ITEMS",
-          message || `Must have at least ${min} items`,
-          soft
-        );
-      }
-    }
-    return null;
-  },
-  max: (value, params, context) => {
-    const max = params?.value;
-    const soft = params?.soft;
-    const message = params?.message;
-    if (value === void 0 || value === null) return null;
-    if (typeof value === "number") {
-      if (value > max) {
-        return createError(
-          context,
-          "MAX_VALUE",
-          message || `Value must be at most ${max}`,
-          soft
-        );
-      }
-    }
-    if (typeof value === "string") {
-      if (value.length > max) {
-        return createError(
-          context,
-          "MAX_LENGTH",
-          message || `Must be at most ${max} characters`,
-          soft
-        );
-      }
-    }
-    if (Array.isArray(value)) {
-      if (value.length > max) {
-        return createError(
-          context,
-          "MAX_ITEMS",
-          message || `Must have at most ${max} items`,
-          soft
-        );
-      }
-    }
-    return null;
-  },
-  email: (value, params, context) => {
-    if (value === void 0 || value === null || value === "") return null;
-    const soft = params?.soft;
-    const message = params?.message;
-    if (typeof value !== "string") {
-      return createError(context, "INVALID_EMAIL", "Email must be a string", soft);
-    }
-    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-    if (!emailRegex.test(value)) {
-      return createError(
-        context,
-        "INVALID_EMAIL",
-        message || "Invalid email address",
-        soft
-      );
-    }
-    return null;
-  },
-  pattern: (value, params, context) => {
-    if (value === void 0 || value === null || value === "") return null;
-    const pattern = params?.pattern;
-    const soft = params?.soft;
-    const message = params?.message;
-    if (typeof value !== "string") return null;
-    const regex = new RegExp(pattern);
-    if (!regex.test(value)) {
-      return createError(
-        context,
-        "PATTERN_MISMATCH",
-        message || `Value does not match required pattern`,
-        soft
-      );
-    }
-    return null;
-  },
-  url: (value, params, context) => {
-    if (value === void 0 || value === null || value === "") return null;
-    const soft = params?.soft;
-    const message = params?.message;
-    if (typeof value !== "string") {
-      return createError(context, "INVALID_URL", "URL must be a string", soft);
-    }
-    try {
-      new URL(value);
-      return null;
-    } catch {
-      return createError(
-        context,
-        "INVALID_URL",
-        message || "Invalid URL format",
-        soft
-      );
-    }
-  },
-  ipAddress: (value, params, context) => {
-    if (value === void 0 || value === null || value === "") return null;
-    const soft = params?.soft;
-    const message = params?.message;
-    if (typeof value !== "string") {
-      return createError(context, "INVALID_IP", "IP address must be a string", soft);
-    }
-    const ipv4Pattern = /^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/;
-    if (!ipv4Pattern.test(value)) {
-      return createError(
-        context,
-        "INVALID_IP",
-        message || "Invalid IP address format",
-        soft
-      );
-    }
-    return null;
-  },
-  enum: (value, params, context) => {
-    if (value === void 0 || value === null) return null;
-    const values = params?.values;
-    const soft = params?.soft;
-    const message = params?.message;
-    if (!values.includes(value)) {
-      return createError(
-        context,
-        "INVALID_ENUM",
-        message || `Value must be one of: ${values.join(", ")}`,
-        soft
-      );
-    }
-    return null;
-  },
-  custom: (value, params, context) => {
-    const validate2 = params?.validate;
-    const soft = params?.soft;
-    const message = params?.message;
-    if (!validate2) return null;
-    const result = validate2(value, context);
-    if (typeof result === "boolean") {
-      if (!result) {
-        return createError(
-          context,
-          "CUSTOM_VALIDATION",
-          message || "Validation failed",
-          soft
-        );
-      }
-      return null;
-    }
-    if (!result.valid) {
-      return createError(
-        context,
-        "CUSTOM_VALIDATION",
-        result.message || message || "Validation failed",
-        soft
-      );
-    }
-    return null;
-  },
-  // Enterprise patterns - matches field against another field
-  matches: (value, params, context) => {
-    if (value === void 0 || value === null) return null;
-    const otherField = params?.field;
-    const soft = params?.soft;
-    const message = params?.message;
-    const root = context.root;
-    const otherValue = root[otherField];
-    if (value !== otherValue) {
-      return createError(
-        context,
-        "FIELD_MISMATCH",
-        message || `Must match ${otherField}`,
-        soft
-      );
-    }
-    return null;
-  },
-  // Integer validation
-  integer: (value, params, context) => {
-    if (value === void 0 || value === null) return null;
-    const soft = params?.soft;
-    const message = params?.message;
-    if (typeof value !== "number" || !Number.isInteger(value)) {
-      return createError(
-        context,
-        "NOT_INTEGER",
-        message || "Value must be an integer",
-        soft
-      );
-    }
-    return null;
-  },
-  // Positive number validation
-  positive: (value, params, context) => {
-    if (value === void 0 || value === null) return null;
-    const soft = params?.soft;
-    const message = params?.message;
-    if (typeof value === "number" && value <= 0) {
-      return createError(
-        context,
-        "NOT_POSITIVE",
-        message || "Value must be positive",
-        soft
-      );
-    }
-    return null;
-  },
-  // Negative number validation
-  negative: (value, params, context) => {
-    if (value === void 0 || value === null) return null;
-    const soft = params?.soft;
-    const message = params?.message;
-    if (typeof value === "number" && value >= 0) {
-      return createError(
-        context,
-        "NOT_NEGATIVE",
-        message || "Value must be negative",
-        soft
-      );
-    }
-    return null;
-  }
-};
-var customValidators = /* @__PURE__ */ new Map();
-function registerValidator(name, validator) {
-  customValidators.set(name, validator);
-}
-function getValidator(name) {
-  return ruleValidators[name] ?? customValidators.get(name);
-}
-function getTypeValidator(type) {
-  return typeValidators[type];
-}
-
-// src/core/engine.ts
-function validateField(fieldDef, value, context) {
-  const errors = [];
-  const typeValidator = getTypeValidator(fieldDef.type);
-  if (typeValidator) {
-    const typeError = typeValidator(value, void 0, context);
-    if (typeError) {
-      errors.push(typeError);
-      return errors;
-    }
-  }
-  if (fieldDef.required) {
-    const requiredValidator = getValidator("required");
-    if (requiredValidator) {
-      const error = requiredValidator(value, void 0, context);
-      if (error) {
-        errors.push(error);
-        return errors;
-      }
-    }
-  } else if (value === void 0 || value === null || value === "") {
-    return errors;
-  }
-  for (const rule of fieldDef.rules) {
-    const validator = getValidator(rule.type);
-    if (!validator) {
-      console.warn(`Unknown validator: ${rule.type}`);
-      continue;
-    }
-    const params = {
-      ...rule.params,
-      soft: rule.soft,
-      message: rule.message
-    };
-    const error = validator(value, params, context);
-    if (error) {
-      errors.push(error);
-    }
-  }
-  if (fieldDef.type === "object" && fieldDef.schema && value !== null && value !== void 0) {
-    const nestedResult = validateSchema(fieldDef.schema, value, context.path, context.root);
-    errors.push(...nestedResult.hardErrors, ...nestedResult.softErrors);
-  }
-  if (fieldDef.type === "array" && fieldDef.items && Array.isArray(value)) {
-    for (let i = 0; i < value.length; i++) {
-      const itemContext = {
-        path: `${context.path}[${i}]`,
-        root: context.root,
-        parent: value
-      };
-      const itemErrors = validateField(fieldDef.items, value[i], itemContext);
-      errors.push(...itemErrors);
-    }
-  }
-  return errors;
-}
-function validateSchema(schema2, data, basePath = "", root) {
-  const hardErrors = [];
-  const softErrors = [];
-  const rootData = root ?? data;
-  for (const [fieldName, fieldDef] of Object.entries(schema2.fields)) {
-    const value = data[fieldName];
-    const path = basePath ? `${basePath}.${fieldName}` : fieldName;
-    const context = {
-      path,
-      root: rootData,
-      parent: data
-    };
-    const errors = validateField(fieldDef, value, context);
-    for (const error of errors) {
-      if (error.severity === "soft") {
-        softErrors.push(error);
-      } else {
-        hardErrors.push(error);
-      }
-    }
-  }
-  return {
-    valid: hardErrors.length === 0,
-    hardErrors,
-    softErrors
-  };
-}
-function validate(schema2, data) {
-  return validateSchema(schema2, data);
-}
-function isValid(schema2, data) {
-  return validate(schema2, data).valid;
-}
-function assertValid(schema2, data) {
-  const result = validate(schema2, data);
-  if (!result.valid) {
-    const error = new Error("Validation failed");
-    error.errors = result.hardErrors;
-    throw error;
-  }
-  return data;
-}
-function mergeResults(...results) {
-  const hardErrors = [];
-  const softErrors = [];
-  for (const result of results) {
-    hardErrors.push(...result.hardErrors);
-    softErrors.push(...result.softErrors);
-  }
-  return {
-    valid: hardErrors.length === 0,
-    hardErrors,
-    softErrors
-  };
-}
-function validResult() {
-  return {
-    valid: true,
-    hardErrors: [],
-    softErrors: []
-  };
-}
-function errorResult(field2, code, message, soft = false) {
-  const error = {
-    field: field2,
-    code,
-    message,
-    severity: soft ? "soft" : "hard"
-  };
-  return {
-    valid: soft,
-    hardErrors: soft ? [] : [error],
-    softErrors: soft ? [error] : []
-  };
-}
+var chunkBVRXGZLS_js = require('./chunk-BVRXGZLS.js');
+var chunkDT2TQZU7_js = require('./chunk-DT2TQZU7.js');
+require('./chunk-76BBWQDH.js');
+require('./chunk-FPCCH55A.js');
+require('./chunk-JEW6U6CB.js');
+require('./chunk-IUXRLMET.js');
+require('./chunk-TXT36BCE.js');
+require('./chunk-66RFUBVU.js');
+require('./chunk-OIYG5D2I.js');
 
 // src/schema/field.ts
 var BaseFieldBuilder = class {
@@ -472,6 +16,9 @@ var BaseFieldBuilder = class {
     this._rules = [];
     this._required = false;
     this._meta = {};
+    this._transforms = [];
+    this._nullable = false;
+    this._nullish = false;
     this._type = type;
   }
   /**
@@ -521,6 +68,59 @@ var BaseFieldBuilder = class {
     });
     return this;
   }
+  /**
+   * Add async custom validation
+   */
+  refineAsync(validate2, options) {
+    const opts = typeof options === "string" ? { message: options } : options || {};
+    this._rules.push({
+      type: "refineAsync",
+      params: { validate: validate2 },
+      message: opts.message,
+      soft: opts.soft,
+      async: true,
+      debounce: opts.debounce,
+      timeout: opts.timeout || 5e3
+    });
+    return this;
+  }
+  /**
+   * Add async soft validation (warning only)
+   */
+  refineAsyncSoft(validate2, options) {
+    const opts = typeof options === "string" ? { message: options } : options || {};
+    return this.refineAsync(validate2, { ...opts, soft: true });
+  }
+  /**
+   * Transform value before validation (applied after preprocessing)
+   */
+  transform(transformer) {
+    this._transforms.push(transformer);
+    return this;
+  }
+  /**
+   * Preprocess value before transformations and validation
+   * Useful for handling null/undefined values
+   */
+  preprocess(preprocessor) {
+    this._preprocess = preprocessor;
+    return this;
+  }
+  /**
+   * Allow null values
+   */
+  nullable() {
+    this._nullable = true;
+    return this;
+  }
+  /**
+   * Allow null or undefined values
+   */
+  nullish() {
+    this._nullish = true;
+    this._nullable = true;
+    return this;
+  }
   /**
    * Add field metadata
    */
@@ -528,6 +128,50 @@ var BaseFieldBuilder = class {
     this._meta = { ...this._meta, ...data };
     return this;
   }
+  /**
+   * Field must not match another field
+   */
+  notMatches(field2, message) {
+    this._rules.push({
+      type: "notMatches",
+      params: { field: field2 },
+      message
+    });
+    return this;
+  }
+  /**
+   * Field must be greater than another field (for numbers)
+   */
+  greaterThan(field2, message) {
+    this._rules.push({
+      type: "greaterThan",
+      params: { field: field2 },
+      message
+    });
+    return this;
+  }
+  /**
+   * Field must be less than another field (for numbers)
+   */
+  lessThan(field2, message) {
+    this._rules.push({
+      type: "lessThan",
+      params: { field: field2 },
+      message
+    });
+    return this;
+  }
+  /**
+   * Field depends on another field being set
+   */
+  dependsOn(field2, message) {
+    this._rules.push({
+      type: "dependsOn",
+      params: { field: field2 },
+      message
+    });
+    return this;
+  }
   /**
    * Build the field definition
    */
@@ -537,7 +181,11 @@ var BaseFieldBuilder = class {
       rules: [...this._rules],
       required: this._required,
       defaultValue: this._defaultValue,
-      meta: Object.keys(this._meta).length > 0 ? this._meta : void 0
+      meta: Object.keys(this._meta).length > 0 ? this._meta : void 0,
+      transforms: this._transforms.length > 0 ? [...this._transforms] : void 0,
+      preprocess: this._preprocess,
+      nullable: this._nullable || void 0,
+      nullish: this._nullish || void 0
     };
   }
 };
@@ -621,6 +269,150 @@ var StringFieldBuilder = class extends BaseFieldBuilder {
     });
     return this;
   }
+  /**
+   * Validate as IPv6 address
+   */
+  ipv6(message) {
+    this._rules.push({
+      type: "ipv6",
+      message
+    });
+    return this;
+  }
+  /**
+   * Only alphabetic characters (a-zA-Z)
+   */
+  alpha(message) {
+    this._rules.push({
+      type: "alpha",
+      message
+    });
+    return this;
+  }
+  /**
+   * Only alphanumeric characters (a-zA-Z0-9)
+   */
+  alphanumeric(message) {
+    this._rules.push({
+      type: "alphanumeric",
+      message
+    });
+    return this;
+  }
+  /**
+   * Only numeric digits
+   */
+  numeric(message) {
+    this._rules.push({
+      type: "numeric",
+      message
+    });
+    return this;
+  }
+  /**
+   * Must be lowercase
+   */
+  lowercase(message) {
+    this._rules.push({
+      type: "lowercase",
+      message
+    });
+    return this;
+  }
+  /**
+   * Must be uppercase
+   */
+  uppercase(message) {
+    this._rules.push({
+      type: "uppercase",
+      message
+    });
+    return this;
+  }
+  /**
+   * URL-friendly slug (lowercase, alphanumeric, hyphens)
+   */
+  slug(message) {
+    this._rules.push({
+      type: "slug",
+      message
+    });
+    return this;
+  }
+  /**
+   * Hexadecimal string
+   */
+  hex(message) {
+    this._rules.push({
+      type: "hex",
+      message
+    });
+    return this;
+  }
+  /**
+   * Base64 encoded string
+   */
+  base64(message) {
+    this._rules.push({
+      type: "base64",
+      message
+    });
+    return this;
+  }
+  /**
+   * Valid JSON string
+   */
+  json(message) {
+    this._rules.push({
+      type: "json",
+      message
+    });
+    return this;
+  }
+  /**
+   * Exact length
+   */
+  length(len, message) {
+    this._rules.push({
+      type: "length",
+      params: { length: len },
+      message
+    });
+    return this;
+  }
+  /**
+   * Must contain substring
+   */
+  contains(substring, message) {
+    this._rules.push({
+      type: "contains",
+      params: { substring },
+      message
+    });
+    return this;
+  }
+  /**
+   * Must start with prefix
+   */
+  startsWith(prefix, message) {
+    this._rules.push({
+      type: "startsWith",
+      params: { prefix },
+      message
+    });
+    return this;
+  }
+  /**
+   * Must end with suffix
+   */
+  endsWith(suffix, message) {
+    this._rules.push({
+      type: "endsWith",
+      params: { suffix },
+      message
+    });
+    return this;
+  }
   /**
    * Match a regex pattern
    */
@@ -668,11 +460,11 @@ var StringFieldBuilder = class extends BaseFieldBuilder {
   }
 };
 var EnumFieldBuilder = class extends BaseFieldBuilder {
-  constructor(values, rules = [], required = false, meta = {}) {
+  constructor(values, rules = [], required2 = false, meta = {}) {
     super("string");
     this._values = values;
     this._rules = [...rules];
-    this._required = required;
+    this._required = required2;
     this._meta = { ...meta };
   }
   /**
@@ -784,6 +576,119 @@ var NumberFieldBuilder = class extends BaseFieldBuilder {
     });
     return this;
   }
+  /**
+   * Must be a valid port number (0-65535)
+   */
+  port(message) {
+    this._rules.push({
+      type: "port",
+      message
+    });
+    return this;
+  }
+  /**
+   * Must be a valid latitude (-90 to 90)
+   */
+  latitude(message) {
+    this._rules.push({
+      type: "latitude",
+      message
+    });
+    return this;
+  }
+  /**
+   * Must be a valid longitude (-180 to 180)
+   */
+  longitude(message) {
+    this._rules.push({
+      type: "longitude",
+      message
+    });
+    return this;
+  }
+  /**
+   * Must be a percentage (0-100)
+   */
+  percentage(message) {
+    this._rules.push({
+      type: "percentage",
+      message
+    });
+    return this;
+  }
+  /**
+   * Must be between min and max (inclusive)
+   */
+  between(min, max, message) {
+    this._rules.push({
+      type: "numberBetween",
+      params: { min, max },
+      message
+    });
+    return this;
+  }
+  /**
+   * Must be divisible by a number
+   */
+  divisibleBy(divisor, message) {
+    this._rules.push({
+      type: "divisibleBy",
+      params: { divisor },
+      message
+    });
+    return this;
+  }
+  /**
+   * Must be a multiple of a number
+   */
+  multipleOf(multiple, message) {
+    this._rules.push({
+      type: "multipleOf",
+      params: { multiple },
+      message
+    });
+    return this;
+  }
+  /**
+   * Must be an even number
+   */
+  even(message) {
+    this._rules.push({
+      type: "even",
+      message
+    });
+    return this;
+  }
+  /**
+   * Must be an odd number
+   */
+  odd(message) {
+    this._rules.push({
+      type: "odd",
+      message
+    });
+    return this;
+  }
+  /**
+   * Must be a safe integer
+   */
+  safe(message) {
+    this._rules.push({
+      type: "safe",
+      message
+    });
+    return this;
+  }
+  /**
+   * Must be a finite number
+   */
+  finite(message) {
+    this._rules.push({
+      type: "finite",
+      message
+    });
+    return this;
+  }
   /**
    * Add a soft validation with message
    */
@@ -916,6 +821,108 @@ var DateFieldBuilder = class extends BaseFieldBuilder {
     });
     return this;
   }
+  /**
+   * Must be today
+   */
+  today(message) {
+    this._rules.push({
+      type: "today",
+      message
+    });
+    return this;
+  }
+  /**
+   * Must be yesterday
+   */
+  yesterday(message) {
+    this._rules.push({
+      type: "yesterday",
+      message
+    });
+    return this;
+  }
+  /**
+   * Must be tomorrow
+   */
+  tomorrow(message) {
+    this._rules.push({
+      type: "tomorrow",
+      message
+    });
+    return this;
+  }
+  /**
+   * Must be within this week
+   */
+  thisWeek(message) {
+    this._rules.push({
+      type: "thisWeek",
+      message
+    });
+    return this;
+  }
+  /**
+   * Must be within this month
+   */
+  thisMonth(message) {
+    this._rules.push({
+      type: "thisMonth",
+      message
+    });
+    return this;
+  }
+  /**
+   * Must be within this year
+   */
+  thisYear(message) {
+    this._rules.push({
+      type: "thisYear",
+      message
+    });
+    return this;
+  }
+  /**
+   * Must be a weekday
+   */
+  weekday(message) {
+    this._rules.push({
+      type: "weekday",
+      message
+    });
+    return this;
+  }
+  /**
+   * Must be a weekend
+   */
+  weekend(message) {
+    this._rules.push({
+      type: "weekend",
+      message
+    });
+    return this;
+  }
+  /**
+   * Validate age is within range
+   */
+  age(min, max, message) {
+    this._rules.push({
+      type: "age",
+      params: { min, max },
+      message
+    });
+    return this;
+  }
+  /**
+   * Must be between two dates
+   */
+  between(start, end, message) {
+    this._rules.push({
+      type: "dateBetween",
+      params: { start, end },
+      message
+    });
+    return this;
+  }
 };
 var ArrayFieldBuilder = class extends BaseFieldBuilder {
   constructor(itemBuilder) {
@@ -979,6 +986,69 @@ var ArrayFieldBuilder = class extends BaseFieldBuilder {
     });
     return this;
   }
+  /**
+   * Must include a specific item
+   */
+  includes(item, message) {
+    this._rules.push({
+      type: "includes",
+      params: { item },
+      message
+    });
+    return this;
+  }
+  /**
+   * Must not include a specific item
+   */
+  excludes(item, message) {
+    this._rules.push({
+      type: "excludes",
+      params: { item },
+      message
+    });
+    return this;
+  }
+  /**
+   * Must be empty
+   */
+  empty(message) {
+    this._rules.push({
+      type: "empty",
+      message
+    });
+    return this;
+  }
+  /**
+   * Must not be empty
+   */
+  notEmpty(message) {
+    this._rules.push({
+      type: "notEmpty",
+      message
+    });
+    return this;
+  }
+  /**
+   * Must be sorted
+   */
+  sorted(order = "asc", message) {
+    this._rules.push({
+      type: "sorted",
+      params: { order },
+      message
+    });
+    return this;
+  }
+  /**
+   * Must not contain falsy values
+   */
+  compact(message) {
+    this._rules.push({
+      type: "compact",
+      message
+    });
+    return this;
+  }
   build() {
     return {
       type: this._type,
@@ -986,7 +1056,11 @@ var ArrayFieldBuilder = class extends BaseFieldBuilder {
       required: this._required,
       defaultValue: this._defaultValue,
       items: this._itemDef,
-      meta: Object.keys(this._meta).length > 0 ? this._meta : void 0
+      meta: Object.keys(this._meta).length > 0 ? this._meta : void 0,
+      transforms: this._transforms.length > 0 ? [...this._transforms] : void 0,
+      preprocess: this._preprocess,
+      nullable: this._nullable || void 0,
+      nullish: this._nullish || void 0
     };
   }
 };
@@ -1006,10 +1080,80 @@ var ObjectFieldBuilder = class extends BaseFieldBuilder {
       required: this._required,
       defaultValue: this._defaultValue,
       schema: this._schema,
-      meta: Object.keys(this._meta).length > 0 ? this._meta : void 0
+      meta: Object.keys(this._meta).length > 0 ? this._meta : void 0,
+      transforms: this._transforms.length > 0 ? [...this._transforms] : void 0,
+      preprocess: this._preprocess,
+      nullable: this._nullable || void 0,
+      nullish: this._nullish || void 0
     };
   }
 };
+var coerce = {
+  /**
+   * Coerce value to string
+   */
+  string() {
+    return new StringFieldBuilder().preprocess((value) => {
+      if (value === null || value === void 0) return value;
+      return String(value);
+    });
+  },
+  /**
+   * Coerce value to number
+   */
+  number() {
+    return new NumberFieldBuilder().preprocess((value) => {
+      if (value === null || value === void 0) return value;
+      if (typeof value === "number") return value;
+      if (typeof value === "string") {
+        const parsed = parseFloat(value);
+        return isNaN(parsed) ? value : parsed;
+      }
+      if (typeof value === "boolean") return value ? 1 : 0;
+      return value;
+    });
+  },
+  /**
+   * Coerce value to boolean
+   */
+  boolean() {
+    return new BooleanFieldBuilder().preprocess((value) => {
+      if (value === null || value === void 0) return value;
+      if (typeof value === "boolean") return value;
+      if (typeof value === "string") {
+        const lower = value.toLowerCase().trim();
+        if (lower === "true" || lower === "1" || lower === "yes" || lower === "on") return true;
+        if (lower === "false" || lower === "0" || lower === "no" || lower === "off") return false;
+      }
+      if (typeof value === "number") return value !== 0;
+      return value;
+    });
+  },
+  /**
+   * Coerce value to date
+   */
+  date() {
+    return new DateFieldBuilder().preprocess((value) => {
+      if (value === null || value === void 0) return value;
+      if (value instanceof Date) return value;
+      if (typeof value === "string" || typeof value === "number") {
+        const date = new Date(value);
+        return isNaN(date.getTime()) ? value : date;
+      }
+      return value;
+    });
+  },
+  /**
+   * Coerce value to array
+   */
+  array(itemBuilder) {
+    return new ArrayFieldBuilder(itemBuilder).preprocess((value) => {
+      if (value === null || value === void 0) return value;
+      if (Array.isArray(value)) return value;
+      return [value];
+    });
+  }
+};
 
 // src/schema/schema.ts
 function schema(fields) {
@@ -1060,6 +1204,86 @@ function partial(baseSchema) {
   }
   return schema(partialFields);
 }
+function deepPartial(baseSchema) {
+  const deepPartialFields = {};
+  for (const [key, builder] of Object.entries(baseSchema._fields)) {
+    const clonedBuilder = Object.create(Object.getPrototypeOf(builder));
+    Object.assign(clonedBuilder, builder);
+    clonedBuilder._required = false;
+    if (builder instanceof ObjectFieldBuilder) {
+      const fieldDef = builder.build();
+      if (fieldDef.schema) {
+        const nestedFields = {};
+        for (const [nestedKey, nestedDef] of Object.entries(fieldDef.schema.fields)) {
+          const nestedBuilder = Object.create(BaseFieldBuilder.prototype);
+          Object.assign(nestedBuilder, {
+            _type: nestedDef.type,
+            _rules: nestedDef.rules || [],
+            _required: false,
+            // Make optional
+            _defaultValue: nestedDef.defaultValue,
+            _meta: nestedDef.meta || {},
+            _transforms: nestedDef.transforms || [],
+            _preprocess: nestedDef.preprocess,
+            _nullable: nestedDef.nullable || false,
+            _nullish: nestedDef.nullish || false
+          });
+          nestedFields[nestedKey] = nestedBuilder;
+        }
+        const nestedSchema = schema(nestedFields);
+        const deepNestedSchema = deepPartial(nestedSchema);
+        clonedBuilder._schema = deepNestedSchema.definition;
+      }
+    }
+    deepPartialFields[key] = clonedBuilder;
+  }
+  return schema(deepPartialFields);
+}
+function passthrough(baseSchema) {
+  const result = schema(baseSchema._fields);
+  result.definition.passthrough = true;
+  return result;
+}
+function strict(baseSchema) {
+  const result = schema(baseSchema._fields);
+  result.definition.strict = true;
+  return result;
+}
+function catchall(baseSchema, fieldBuilder) {
+  const result = schema(baseSchema._fields);
+  result.definition.catchall = fieldBuilder.build();
+  return result;
+}
+function required(baseSchema, keys) {
+  const keySet = new Set(keys);
+  const newFields = {};
+  for (const [key, builder] of Object.entries(baseSchema._fields)) {
+    if (keySet.has(key)) {
+      const clonedBuilder = Object.create(Object.getPrototypeOf(builder));
+      Object.assign(clonedBuilder, builder);
+      clonedBuilder._required = true;
+      newFields[key] = clonedBuilder;
+    } else {
+      newFields[key] = builder;
+    }
+  }
+  return schema(newFields);
+}
+function optional(baseSchema, keys) {
+  const keySet = new Set(keys);
+  const newFields = {};
+  for (const [key, builder] of Object.entries(baseSchema._fields)) {
+    if (keySet.has(key)) {
+      const clonedBuilder = Object.create(Object.getPrototypeOf(builder));
+      Object.assign(clonedBuilder, builder);
+      clonedBuilder._required = false;
+      newFields[key] = clonedBuilder;
+    } else {
+      newFields[key] = builder;
+    }
+  }
+  return schema(newFields);
+}
 function merge(schema1, schema2) {
   return schema({
     ...schema1._fields,
@@ -1117,20 +1341,74 @@ var field = {
   }
 };
 
-// src/types/index.ts
-function toEnterpriseResponse(result, data) {
-  return {
-    status: result.valid ? "success" : "validation_error",
-    data: result.valid ? data : void 0,
-    errors: [...result.hardErrors, ...result.softErrors],
-    msg: result.valid ? "Validation successful" : "Validation failed",
-    validation: {
-      hard_validations: result.hardErrors,
-      soft_validations: result.softErrors
-    }
-  };
-}
-
+Object.defineProperty(exports, "toEnterpriseResponse", {
+  enumerable: true,
+  get: function () { return chunkBVRXGZLS_js.toEnterpriseResponse; }
+});
+Object.defineProperty(exports, "assertValid", {
+  enumerable: true,
+  get: function () { return chunkDT2TQZU7_js.assertValid; }
+});
+Object.defineProperty(exports, "assertValidAsync", {
+  enumerable: true,
+  get: function () { return chunkDT2TQZU7_js.assertValidAsync; }
+});
+Object.defineProperty(exports, "errorResult", {
+  enumerable: true,
+  get: function () { return chunkDT2TQZU7_js.errorResult; }
+});
+Object.defineProperty(exports, "getTypeValidator", {
+  enumerable: true,
+  get: function () { return chunkDT2TQZU7_js.getTypeValidator; }
+});
+Object.defineProperty(exports, "getValidator", {
+  enumerable: true,
+  get: function () { return chunkDT2TQZU7_js.getValidator; }
+});
+Object.defineProperty(exports, "isValid", {
+  enumerable: true,
+  get: function () { return chunkDT2TQZU7_js.isValid; }
+});
+Object.defineProperty(exports, "isValidAsync", {
+  enumerable: true,
+  get: function () { return chunkDT2TQZU7_js.isValidAsync; }
+});
+Object.defineProperty(exports, "mergeResults", {
+  enumerable: true,
+  get: function () { return chunkDT2TQZU7_js.mergeResults; }
+});
+Object.defineProperty(exports, "registerValidator", {
+  enumerable: true,
+  get: function () { return chunkDT2TQZU7_js.registerValidator; }
+});
+Object.defineProperty(exports, "ruleValidators", {
+  enumerable: true,
+  get: function () { return chunkDT2TQZU7_js.ruleValidators; }
+});
+Object.defineProperty(exports, "typeValidators", {
+  enumerable: true,
+  get: function () { return chunkDT2TQZU7_js.typeValidators; }
+});
+Object.defineProperty(exports, "validResult", {
+  enumerable: true,
+  get: function () { return chunkDT2TQZU7_js.validResult; }
+});
+Object.defineProperty(exports, "validate", {
+  enumerable: true,
+  get: function () { return chunkDT2TQZU7_js.validate; }
+});
+Object.defineProperty(exports, "validateAsync", {
+  enumerable: true,
+  get: function () { return chunkDT2TQZU7_js.validateAsync; }
+});
+Object.defineProperty(exports, "validateSchema", {
+  enumerable: true,
+  get: function () { return chunkDT2TQZU7_js.validateSchema; }
+});
+Object.defineProperty(exports, "validateSchemaAsync", {
+  enumerable: true,
+  get: function () { return chunkDT2TQZU7_js.validateSchemaAsync; }
+});
 exports.ArrayFieldBuilder = ArrayFieldBuilder;
 exports.BaseFieldBuilder = BaseFieldBuilder;
 exports.BooleanFieldBuilder = BooleanFieldBuilder;
@@ -1139,25 +1417,17 @@ exports.EnumFieldBuilder = EnumFieldBuilder;
 exports.NumberFieldBuilder = NumberFieldBuilder;
 exports.ObjectFieldBuilder = ObjectFieldBuilder;
 exports.StringFieldBuilder = StringFieldBuilder;
-exports.assertValid = assertValid;
-exports.errorResult = errorResult;
+exports.catchall = catchall;
+exports.coerce = coerce;
+exports.deepPartial = deepPartial;
 exports.extend = extend;
 exports.field = field;
-exports.getTypeValidator = getTypeValidator;
-exports.getValidator = getValidator;
-exports.isValid = isValid;
 exports.merge = merge;
-exports.mergeResults = mergeResults;
 exports.omit = omit;
+exports.optional = optional;
 exports.partial = partial;
+exports.passthrough = passthrough;
 exports.pick = pick;
-exports.registerValidator = registerValidator;
-exports.ruleValidators = ruleValidators;
+exports.required = required;
 exports.schema = schema;
-exports.toEnterpriseResponse = toEnterpriseResponse;
-exports.typeValidators = typeValidators;
-exports.validResult = validResult;
-exports.validate = validate;
-exports.validateSchema = validateSchema;
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map
+exports.strict = strict;