unischema 1.0.1 → 1.2.0

package/dist/{schema-D9DGC9E_.d.mts → schema-Dtp-joeT.d.ts}

@@ -1,81 +1,4 @@
-/**
- * Core types for the FormSchema validation engine
- */
-type ValidationSeverity = 'hard' | 'soft';
-interface ValidationError {
-    /** Field path (e.g., "email" or "address.city") */
-    field: 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;
-}
-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[];
-}
-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;
-}
-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>;
-}
-interface SchemaDefinition {
-    /** Field definitions keyed by field name */
-    fields: Record<string, FieldDefinition>;
-    /** Schema metadata */
-    meta?: Record<string, unknown>;
-}
-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;
-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;
+import { F as FieldDefinition, c as ValidationRule, V as ValidatorContext, A as AsyncRefineFn, d as AsyncValidationOptions, S as SchemaDefinition } from './index-C17xs-fU.js';
 
 /**
  * Fluent field builder for schema definitions
@@ -87,6 +10,10 @@ declare class BaseFieldBuilder<T> {
     protected _required: boolean;
     protected _defaultValue?: T;
     protected _meta: Record<string, unknown>;
+    protected _transforms: Array<(value: unknown) => unknown>;
+    protected _preprocess?: (value: unknown) => unknown;
+    protected _nullable: boolean;
+    protected _nullish: boolean;
     constructor(type: FieldDefinition['type']);
     /**
      * Mark field as required
@@ -114,10 +41,51 @@ declare class BaseFieldBuilder<T> {
         valid: boolean;
         message?: string;
     } | boolean, message?: string): this;
+    /**
+     * Add async custom validation
+     */
+    refineAsync(validate: AsyncRefineFn<T>, options?: AsyncValidationOptions | string): this;
+    /**
+     * Add async soft validation (warning only)
+     */
+    refineAsyncSoft(validate: AsyncRefineFn<T>, options?: Omit<AsyncValidationOptions, 'soft'> | string): this;
+    /**
+     * Transform value before validation (applied after preprocessing)
+     */
+    transform<U = T>(transformer: (value: T) => U): BaseFieldBuilder<U>;
+    /**
+     * Preprocess value before transformations and validation
+     * Useful for handling null/undefined values
+     */
+    preprocess(preprocessor: (value: unknown) => unknown): this;
+    /**
+     * Allow null values
+     */
+    nullable(): this;
+    /**
+     * Allow null or undefined values
+     */
+    nullish(): this;
     /**
      * Add field metadata
      */
     meta(data: Record<string, unknown>): this;
+    /**
+     * Field must not match another field
+     */
+    notMatches(field: string, message?: string): this;
+    /**
+     * Field must be greater than another field (for numbers)
+     */
+    greaterThan(field: string, message?: string): this;
+    /**
+     * Field must be less than another field (for numbers)
+     */
+    lessThan(field: string, message?: string): this;
+    /**
+     * Field depends on another field being set
+     */
+    dependsOn(field: string, message?: string): this;
     /**
      * Build the field definition
      */
@@ -153,6 +121,62 @@ declare class StringFieldBuilder extends BaseFieldBuilder<string> {
      * Validate as IP address (IPv4)
      */
     ipAddress(message?: string): this;
+    /**
+     * Validate as IPv6 address
+     */
+    ipv6(message?: string): this;
+    /**
+     * Only alphabetic characters (a-zA-Z)
+     */
+    alpha(message?: string): this;
+    /**
+     * Only alphanumeric characters (a-zA-Z0-9)
+     */
+    alphanumeric(message?: string): this;
+    /**
+     * Only numeric digits
+     */
+    numeric(message?: string): this;
+    /**
+     * Must be lowercase
+     */
+    lowercase(message?: string): this;
+    /**
+     * Must be uppercase
+     */
+    uppercase(message?: string): this;
+    /**
+     * URL-friendly slug (lowercase, alphanumeric, hyphens)
+     */
+    slug(message?: string): this;
+    /**
+     * Hexadecimal string
+     */
+    hex(message?: string): this;
+    /**
+     * Base64 encoded string
+     */
+    base64(message?: string): this;
+    /**
+     * Valid JSON string
+     */
+    json(message?: string): this;
+    /**
+     * Exact length
+     */
+    length(len: number, message?: string): this;
+    /**
+     * Must contain substring
+     */
+    contains(substring: string, message?: string): this;
+    /**
+     * Must start with prefix
+     */
+    startsWith(prefix: string, message?: string): this;
+    /**
+     * Must end with suffix
+     */
+    endsWith(suffix: string, message?: string): this;
     /**
      * Match a regex pattern
      */
@@ -213,6 +237,50 @@ declare class NumberFieldBuilder extends BaseFieldBuilder<number> {
      * Must be negative
      */
     negative(message?: string): this;
+    /**
+     * Must be a valid port number (0-65535)
+     */
+    port(message?: string): this;
+    /**
+     * Must be a valid latitude (-90 to 90)
+     */
+    latitude(message?: string): this;
+    /**
+     * Must be a valid longitude (-180 to 180)
+     */
+    longitude(message?: string): this;
+    /**
+     * Must be a percentage (0-100)
+     */
+    percentage(message?: string): this;
+    /**
+     * Must be between min and max (inclusive)
+     */
+    between(min: number, max: number, message?: string): this;
+    /**
+     * Must be divisible by a number
+     */
+    divisibleBy(divisor: number, message?: string): this;
+    /**
+     * Must be a multiple of a number
+     */
+    multipleOf(multiple: number, message?: string): this;
+    /**
+     * Must be an even number
+     */
+    even(message?: string): this;
+    /**
+     * Must be an odd number
+     */
+    odd(message?: string): this;
+    /**
+     * Must be a safe integer
+     */
+    safe(message?: string): this;
+    /**
+     * Must be a finite number
+     */
+    finite(message?: string): this;
     /**
      * Add a soft validation with message
      */
@@ -255,6 +323,46 @@ declare class DateFieldBuilder extends BaseFieldBuilder<Date> {
      * Must be in the future
      */
     future(message?: string): this;
+    /**
+     * Must be today
+     */
+    today(message?: string): this;
+    /**
+     * Must be yesterday
+     */
+    yesterday(message?: string): this;
+    /**
+     * Must be tomorrow
+     */
+    tomorrow(message?: string): this;
+    /**
+     * Must be within this week
+     */
+    thisWeek(message?: string): this;
+    /**
+     * Must be within this month
+     */
+    thisMonth(message?: string): this;
+    /**
+     * Must be within this year
+     */
+    thisYear(message?: string): this;
+    /**
+     * Must be a weekday
+     */
+    weekday(message?: string): this;
+    /**
+     * Must be a weekend
+     */
+    weekend(message?: string): this;
+    /**
+     * Validate age is within range
+     */
+    age(min?: number, max?: number, message?: string): this;
+    /**
+     * Must be between two dates
+     */
+    between(start: Date | string, end: Date | string, message?: string): this;
 }
 declare class ArrayFieldBuilder<T> extends BaseFieldBuilder<T[]> {
     private _itemDef?;
@@ -275,6 +383,30 @@ declare class ArrayFieldBuilder<T> extends BaseFieldBuilder<T[]> {
      * All items must be unique
      */
     unique(message?: string): this;
+    /**
+     * Must include a specific item
+     */
+    includes(item: T, message?: string): this;
+    /**
+     * Must not include a specific item
+     */
+    excludes(item: T, message?: string): this;
+    /**
+     * Must be empty
+     */
+    empty(message?: string): this;
+    /**
+     * Must not be empty
+     */
+    notEmpty(message?: string): this;
+    /**
+     * Must be sorted
+     */
+    sorted(order?: 'asc' | 'desc', message?: string): this;
+    /**
+     * Must not contain falsy values
+     */
+    compact(message?: string): this;
     build(): FieldDefinition<T[]>;
 }
 declare class ObjectFieldBuilder<T extends Record<string, unknown>> extends BaseFieldBuilder<T> {
@@ -282,6 +414,31 @@ declare class ObjectFieldBuilder<T extends Record<string, unknown>> extends Base
     constructor(schemaFields: Record<string, BaseFieldBuilder<unknown>>);
     build(): FieldDefinition<T>;
 }
+/**
+ * Coercion namespace for automatic type conversion
+ */
+declare const coerce: {
+    /**
+     * Coerce value to string
+     */
+    string(): StringFieldBuilder;
+    /**
+     * Coerce value to number
+     */
+    number(): NumberFieldBuilder;
+    /**
+     * Coerce value to boolean
+     */
+    boolean(): BooleanFieldBuilder;
+    /**
+     * Coerce value to date
+     */
+    date(): DateFieldBuilder;
+    /**
+     * Coerce value to array
+     */
+    array<T>(itemBuilder?: BaseFieldBuilder<T>): ArrayFieldBuilder<T>;
+};
 
 /**
  * Schema builder and type inference
@@ -315,6 +472,30 @@ declare function omit<T extends Record<string, unknown>, K extends keyof T>(base
  * Make all fields optional
  */
 declare function partial<T extends Record<string, unknown>>(baseSchema: SchemaBuilder<T>): SchemaBuilder<Partial<T>>;
+/**
+ * Make all fields optional recursively (deep partial)
+ */
+declare function deepPartial<T extends Record<string, unknown>>(baseSchema: SchemaBuilder<T>): SchemaBuilder<DeepPartial<T>>;
+/**
+ * Allow unknown keys to pass through
+ */
+declare function passthrough<T extends Record<string, unknown>>(baseSchema: SchemaBuilder<T>): SchemaBuilder<T>;
+/**
+ * Strict mode - reject unknown keys
+ */
+declare function strict<T extends Record<string, unknown>>(baseSchema: SchemaBuilder<T>): SchemaBuilder<T>;
+/**
+ * Default handler for unknown keys (catchall)
+ */
+declare function catchall<T extends Record<string, unknown>>(baseSchema: SchemaBuilder<T>, fieldBuilder: BaseFieldBuilder<unknown>): SchemaBuilder<T>;
+/**
+ * Make specific fields required
+ */
+declare function required<T extends Record<string, unknown>, K extends keyof T>(baseSchema: SchemaBuilder<T>, keys: K[]): SchemaBuilder<T>;
+/**
+ * Make specific fields optional
+ */
+declare function optional<T extends Record<string, unknown>, K extends keyof T>(baseSchema: SchemaBuilder<T>, keys: K[]): SchemaBuilder<T>;
 /**
  * Merge multiple schemas
  */
@@ -329,6 +510,10 @@ type InferFields<F extends Record<string, BaseFieldBuilder<unknown>>> = {
 type InferInput<S> = S extends SchemaBuilder<infer T> ? T : never;
 /** Infer output type from a schema (validated data) */
 type InferOutput<S> = S extends SchemaBuilder<infer T> ? T : never;
+/** Deep partial type helper */
+type DeepPartial<T> = T extends object ? {
+    [P in keyof T]?: DeepPartial<T[P]>;
+} : T;
 /**
  * Field factory for creating typed field builders
  */
@@ -363,4 +548,4 @@ declare const field: {
     enum<E extends string>(values: readonly E[]): StringFieldBuilder;
 };
 
-export { ArrayFieldBuilder as A, BaseFieldBuilder as B, DateFieldBuilder as D, EnumFieldBuilder as E, type FieldType as F, type InferInput as I, NumberFieldBuilder as N, ObjectFieldBuilder as O, type SchemaDefinition as S, type ValidationResult as V, type ValidatorFn as a, partial as b, type InferOutput as c, type SchemaBuilder as d, extend as e, field as f, StringFieldBuilder as g, BooleanFieldBuilder as h, type ValidationSeverity as i, type ValidationError as j, type ValidationRule as k, type FieldDefinition as l, merge as m, type ValidatorContext as n, omit as o, pick as p, type EnterpriseValidationResponse as q, schema as s, toEnterpriseResponse as t };
+export { ArrayFieldBuilder as A, BaseFieldBuilder as B, type DeepPartial as D, EnumFieldBuilder as E, type InferInput as I, NumberFieldBuilder as N, ObjectFieldBuilder as O, type SchemaBuilder as S, partial as a, passthrough as b, strict as c, deepPartial as d, extend as e, catchall as f, optional as g, field as h, coerce as i, type InferOutput as j, StringFieldBuilder as k, BooleanFieldBuilder as l, merge as m, DateFieldBuilder as n, omit as o, pick as p, required as r, schema as s };

package/dist/validators/array.d.mts

@@ -0,0 +1,15 @@
+import { f as ValidatorFn } from '../index-C17xs-fU.mjs';
+
+declare const includesValidator: ValidatorFn;
+
+declare const excludesValidator: ValidatorFn;
+
+declare const emptyValidator: ValidatorFn;
+
+declare const notEmptyValidator: ValidatorFn;
+
+declare const sortedValidator: ValidatorFn;
+
+declare const compactValidator: ValidatorFn;
+
+export { compactValidator, emptyValidator, excludesValidator, includesValidator, notEmptyValidator, sortedValidator };

package/dist/validators/array.d.ts

@@ -0,0 +1,15 @@
+import { f as ValidatorFn } from '../index-C17xs-fU.js';
+
+declare const includesValidator: ValidatorFn;
+
+declare const excludesValidator: ValidatorFn;
+
+declare const emptyValidator: ValidatorFn;
+
+declare const notEmptyValidator: ValidatorFn;
+
+declare const sortedValidator: ValidatorFn;
+
+declare const compactValidator: ValidatorFn;
+
+export { compactValidator, emptyValidator, excludesValidator, includesValidator, notEmptyValidator, sortedValidator };

package/dist/validators/array.js

@@ -0,0 +1,31 @@
+'use strict';
+
+var chunk66RFUBVU_js = require('../chunk-66RFUBVU.js');
+require('../chunk-OIYG5D2I.js');
+
+
+
+Object.defineProperty(exports, "compactValidator", {
+  enumerable: true,
+  get: function () { return chunk66RFUBVU_js.compactValidator; }
+});
+Object.defineProperty(exports, "emptyValidator", {
+  enumerable: true,
+  get: function () { return chunk66RFUBVU_js.emptyValidator; }
+});
+Object.defineProperty(exports, "excludesValidator", {
+  enumerable: true,
+  get: function () { return chunk66RFUBVU_js.excludesValidator; }
+});
+Object.defineProperty(exports, "includesValidator", {
+  enumerable: true,
+  get: function () { return chunk66RFUBVU_js.includesValidator; }
+});
+Object.defineProperty(exports, "notEmptyValidator", {
+  enumerable: true,
+  get: function () { return chunk66RFUBVU_js.notEmptyValidator; }
+});
+Object.defineProperty(exports, "sortedValidator", {
+  enumerable: true,
+  get: function () { return chunk66RFUBVU_js.sortedValidator; }
+});

package/dist/validators/array.mjs

@@ -0,0 +1,2 @@
+export { compactValidator, emptyValidator, excludesValidator, includesValidator, notEmptyValidator, sortedValidator } from '../chunk-5A4ITJVD.mjs';
+import '../chunk-KZZ7NVU3.mjs';

package/dist/validators/common.d.mts

@@ -0,0 +1,13 @@
+import { f as ValidatorFn } from '../index-C17xs-fU.mjs';
+
+declare const notMatchesValidator: ValidatorFn;
+
+declare const greaterThanValidator: ValidatorFn;
+
+declare const lessThanValidator: ValidatorFn;
+
+declare const whenValidator: ValidatorFn;
+
+declare const dependsOnValidator: ValidatorFn;
+
+export { dependsOnValidator, greaterThanValidator, lessThanValidator, notMatchesValidator, whenValidator };

package/dist/validators/common.d.ts

@@ -0,0 +1,13 @@
+import { f as ValidatorFn } from '../index-C17xs-fU.js';
+
+declare const notMatchesValidator: ValidatorFn;
+
+declare const greaterThanValidator: ValidatorFn;
+
+declare const lessThanValidator: ValidatorFn;
+
+declare const whenValidator: ValidatorFn;
+
+declare const dependsOnValidator: ValidatorFn;
+
+export { dependsOnValidator, greaterThanValidator, lessThanValidator, notMatchesValidator, whenValidator };

package/dist/validators/common.js

@@ -0,0 +1,27 @@
+'use strict';
+
+var chunkFPCCH55A_js = require('../chunk-FPCCH55A.js');
+require('../chunk-OIYG5D2I.js');
+
+
+
+Object.defineProperty(exports, "dependsOnValidator", {
+  enumerable: true,
+  get: function () { return chunkFPCCH55A_js.dependsOnValidator; }
+});
+Object.defineProperty(exports, "greaterThanValidator", {
+  enumerable: true,
+  get: function () { return chunkFPCCH55A_js.greaterThanValidator; }
+});
+Object.defineProperty(exports, "lessThanValidator", {
+  enumerable: true,
+  get: function () { return chunkFPCCH55A_js.lessThanValidator; }
+});
+Object.defineProperty(exports, "notMatchesValidator", {
+  enumerable: true,
+  get: function () { return chunkFPCCH55A_js.notMatchesValidator; }
+});
+Object.defineProperty(exports, "whenValidator", {
+  enumerable: true,
+  get: function () { return chunkFPCCH55A_js.whenValidator; }
+});

package/dist/validators/common.mjs

@@ -0,0 +1,2 @@
+export { dependsOnValidator, greaterThanValidator, lessThanValidator, notMatchesValidator, whenValidator } from '../chunk-KZCV5IW4.mjs';
+import '../chunk-KZZ7NVU3.mjs';

package/dist/validators/date.d.mts

@@ -0,0 +1,23 @@
+import { f as ValidatorFn } from '../index-C17xs-fU.mjs';
+
+declare const todayValidator: ValidatorFn;
+
+declare const yesterdayValidator: ValidatorFn;
+
+declare const tomorrowValidator: ValidatorFn;
+
+declare const thisWeekValidator: ValidatorFn;
+
+declare const thisMonthValidator: ValidatorFn;
+
+declare const thisYearValidator: ValidatorFn;
+
+declare const weekdayValidator: ValidatorFn;
+
+declare const weekendValidator: ValidatorFn;
+
+declare const ageValidator: ValidatorFn;
+
+declare const betweenValidator: ValidatorFn;
+
+export { ageValidator, betweenValidator, thisMonthValidator, thisWeekValidator, thisYearValidator, todayValidator, tomorrowValidator, weekdayValidator, weekendValidator, yesterdayValidator };

package/dist/validators/date.d.ts

@@ -0,0 +1,23 @@
+import { f as ValidatorFn } from '../index-C17xs-fU.js';
+
+declare const todayValidator: ValidatorFn;
+
+declare const yesterdayValidator: ValidatorFn;
+
+declare const tomorrowValidator: ValidatorFn;
+
+declare const thisWeekValidator: ValidatorFn;
+
+declare const thisMonthValidator: ValidatorFn;
+
+declare const thisYearValidator: ValidatorFn;
+
+declare const weekdayValidator: ValidatorFn;
+
+declare const weekendValidator: ValidatorFn;
+
+declare const ageValidator: ValidatorFn;
+
+declare const betweenValidator: ValidatorFn;
+
+export { ageValidator, betweenValidator, thisMonthValidator, thisWeekValidator, thisYearValidator, todayValidator, tomorrowValidator, weekdayValidator, weekendValidator, yesterdayValidator };

package/dist/validators/date.js

@@ -0,0 +1,47 @@
+'use strict';
+
+var chunkTXT36BCE_js = require('../chunk-TXT36BCE.js');
+require('../chunk-OIYG5D2I.js');
+
+
+
+Object.defineProperty(exports, "ageValidator", {
+  enumerable: true,
+  get: function () { return chunkTXT36BCE_js.ageValidator; }
+});
+Object.defineProperty(exports, "betweenValidator", {
+  enumerable: true,
+  get: function () { return chunkTXT36BCE_js.betweenValidator; }
+});
+Object.defineProperty(exports, "thisMonthValidator", {
+  enumerable: true,
+  get: function () { return chunkTXT36BCE_js.thisMonthValidator; }
+});
+Object.defineProperty(exports, "thisWeekValidator", {
+  enumerable: true,
+  get: function () { return chunkTXT36BCE_js.thisWeekValidator; }
+});
+Object.defineProperty(exports, "thisYearValidator", {
+  enumerable: true,
+  get: function () { return chunkTXT36BCE_js.thisYearValidator; }
+});
+Object.defineProperty(exports, "todayValidator", {
+  enumerable: true,
+  get: function () { return chunkTXT36BCE_js.todayValidator; }
+});
+Object.defineProperty(exports, "tomorrowValidator", {
+  enumerable: true,
+  get: function () { return chunkTXT36BCE_js.tomorrowValidator; }
+});
+Object.defineProperty(exports, "weekdayValidator", {
+  enumerable: true,
+  get: function () { return chunkTXT36BCE_js.weekdayValidator; }
+});
+Object.defineProperty(exports, "weekendValidator", {
+  enumerable: true,
+  get: function () { return chunkTXT36BCE_js.weekendValidator; }
+});
+Object.defineProperty(exports, "yesterdayValidator", {
+  enumerable: true,
+  get: function () { return chunkTXT36BCE_js.yesterdayValidator; }
+});

package/dist/validators/date.mjs

@@ -0,0 +1,2 @@
+export { ageValidator, betweenValidator, thisMonthValidator, thisWeekValidator, thisYearValidator, todayValidator, tomorrowValidator, weekdayValidator, weekendValidator, yesterdayValidator } from '../chunk-7XES4A3M.mjs';
+import '../chunk-KZZ7NVU3.mjs';

package/dist/validators/index.d.mts

@@ -0,0 +1,46 @@
+export { alphaValidator, alphanumericValidator, base64Validator, containsValidator, emailValidator, endsWithValidator, hexValidator, ipAddressValidator, ipv6Validator, jsonValidator, lengthValidator, lowercaseValidator, numericValidator, slugValidator, startsWithValidator, uppercaseValidator, urlValidator } from './string.mjs';
+export { divisibleByValidator, evenValidator, finiteValidator, latitudeValidator, longitudeValidator, multipleOfValidator, betweenValidator as numberBetweenValidator, oddValidator, percentageValidator, portValidator, safeValidator } from './number.mjs';
+export { ageValidator, betweenValidator as dateBetweenValidator, thisMonthValidator, thisWeekValidator, thisYearValidator, todayValidator, tomorrowValidator, weekdayValidator, weekendValidator, yesterdayValidator } from './date.mjs';
+export { compactValidator, emptyValidator, excludesValidator, includesValidator, notEmptyValidator, sortedValidator } from './array.mjs';
+export { keysValidator, omitValidator, pickValidator, strictValidator } from './object.mjs';
+export { dependsOnValidator, greaterThanValidator, lessThanValidator, notMatchesValidator, whenValidator } from './common.mjs';
+import { V as ValidatorContext, a as ValidationError } from '../index-C17xs-fU.mjs';
+
+/**
+ * Shared utilities for validators
+ */
+
+/**
+ * Create a validation error
+ */
+declare function createError(context: ValidatorContext, code: string, message: string, soft?: boolean, received?: unknown, expected?: unknown): ValidationError;
+/**
+ * Check if value is empty (null, undefined, or empty string)
+ */
+declare function isEmpty(value: unknown): boolean;
+/**
+ * Check if value is a valid string
+ */
+declare function isString(value: unknown): value is string;
+/**
+ * Check if value is a valid number
+ */
+declare function isNumber(value: unknown): value is number;
+/**
+ * Check if value is a valid date
+ */
+declare function isDate(value: unknown): value is Date;
+/**
+ * Parse a date from various formats
+ */
+declare function parseDate(value: unknown): Date | null;
+/**
+ * Check if value is an array
+ */
+declare function isArray(value: unknown): value is unknown[];
+/**
+ * Check if value is a plain object
+ */
+declare function isObject(value: unknown): value is Record<string, unknown>;
+
+export { createError, isArray, isDate, isEmpty, isNumber, isObject, isString, parseDate };