@satoshibits/functional 1.0.2

package/dist/validation.mjs

@@ -0,0 +1,852 @@
+"use strict";
+/**
+ * @module validation
+ * @description Functional validation utilities using Result types for composable,
+ * type-safe data validation. This module provides a rich set of validators and
+ * combinators for building complex validation schemas. Unlike traditional validation
+ * libraries that throw exceptions, all validators return Result types, making
+ * error handling explicit and composable. Validators can be combined, transformed,
+ * and reused to build sophisticated validation logic.
+ *
+ * @example
+ * ```typescript
+ * import { Validation, validators, schema, ValidationError } from './validation.mts';
+ *
+ * // simple validators
+ * const validateAge = validators.number.between(0, 150);
+ * const validateEmail = validators.string.email();
+ *
+ * // combining validators
+ * const validatePassword = Validation.all(
+ *   validators.string.minLength(8),
+ *   validators.string.matches(/[A-Z]/, 'Must contain uppercase'),
+ *   validators.string.matches(/[0-9]/, 'Must contain number')
+ * );
+ *
+ * // object validation schema
+ * const userSchema = schema({
+ *   name: validators.string.nonEmpty(),
+ *   email: validateEmail,
+ *   age: Validation.optional(validateAge),
+ *   password: validatePassword
+ * });
+ *
+ * // using the validator
+ * const result = userSchema({
+ *   name: 'John Doe',
+ *   email: 'john@example.com',
+ *   age: 30,
+ *   password: 'SecurePass123'
+ * });
+ *
+ * if (result.success) {
+ *   console.log('Valid user:', result.data);
+ * } else {
+ *   console.error('Validation errors:', result.error.errors);
+ * }
+ * ```
+ *
+ * @category Core
+ * @since 2025-07-03
+ */
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+import { Result } from "./result.mjs";
+/**
+ * Custom validation error that can hold multiple error messages.
+ * @description Extends the standard Error class to accumulate multiple validation
+ * errors. This allows validators to collect all errors rather than failing on
+ * the first error, providing better user experience for form validation.
+ *
+ * @category Errors
+ * @example
+ * // Creating validation errors
+ * const error = new ValidationError(['Name is required', 'Email is invalid']);
+ * console.log(error.message); // "Validation failed: Name is required, Email is invalid"
+ *
+ * @example
+ * // Working with errors
+ * if (!result.success) {
+ *   const validationError = result.error;
+ *   console.log('First error:', validationError.firstError());
+ *   console.log('All errors:', validationError.errors);
+ *
+ *   if (validationError.hasError('Email is invalid')) {
+ *     // Handle email error specifically
+ *   }
+ * }
+ *
+ * @since 2025-07-03
+ */
+var ValidationError = /** @class */ (function (_super) {
+    __extends(ValidationError, _super);
+    /**
+     * Creates a new ValidationError with the given error messages.
+     *
+     * @param {string[]} errors - Array of error messages
+     */
+    function ValidationError(errors) {
+        var _this = _super.call(this, "Validation failed: ".concat(errors.join(", "))) || this;
+        _this.errors = errors;
+        _this.name = "ValidationError";
+        return _this;
+    }
+    /**
+     * Adds additional errors to this validation error.
+     * @description Creates a new ValidationError with the combined errors.
+     * The original error remains unchanged (immutable).
+     *
+     * @param {string[]} newErrors - Additional error messages to add
+     * @returns {ValidationError} A new ValidationError with all errors
+     *
+     * @example
+     * const error1 = new ValidationError(['Name required']);
+     * const error2 = error1.addErrors(['Email invalid']);
+     * // error2.errors => ['Name required', 'Email invalid']
+     * // error1.errors => ['Name required'] (unchanged)
+     */
+    ValidationError.prototype.addErrors = function (newErrors) {
+        return new ValidationError(__spreadArray(__spreadArray([], this.errors, true), newErrors, true));
+    };
+    /**
+     * Checks if this error contains a specific error message.
+     * @description Useful for conditional error handling based on specific
+     * validation failures.
+     *
+     * @param {string} error - The error message to check for
+     * @returns {boolean} True if the error message is present
+     *
+     * @example
+     * if (!result.success && result.error.hasError('Email is invalid')) {
+     *   showEmailHelp();
+     * }
+     */
+    ValidationError.prototype.hasError = function (error) {
+        return this.errors.includes(error);
+    };
+    /**
+     * Gets the first error message.
+     * @description Returns the first error in the list, useful when you only
+     * want to display one error at a time.
+     *
+     * @returns {string | undefined} The first error message or undefined if no errors
+     *
+     * @example
+     * const firstError = validationError.firstError();
+     * if (firstError) {
+     *   showToast(firstError);
+     * }
+     */
+    ValidationError.prototype.firstError = function () {
+        return this.errors[0];
+    };
+    return ValidationError;
+}(Error));
+export { ValidationError };
+/**
+ * Validation utilities for creating and composing validators.
+ * @description The main namespace for validation combinators and utilities.
+ * Provides methods for creating, combining, and transforming validators
+ * in a functional style.
+ *
+ * @category Utilities
+ * @since 2025-07-03
+ */
+export var Validation = {
+    /**
+     * Creates a validator that always succeeds.
+     * @description Useful as a default validator or when conditionally applying
+     * validation. The value passes through unchanged.
+     *
+     * @template T - The type of value
+     * @returns {Validator<T>} A validator that always returns success
+     *
+     * @category Constructors
+     * @example
+     * // Conditional validation
+     * const validator = shouldValidate
+     *   ? validators.string.email()
+     *   : Validation.success();
+     *
+     * @since 2025-07-03
+     */
+    success: function () {
+        return function (value) {
+            return Result.ok(value);
+        };
+    },
+    /**
+     * Creates a validator that always fails with the given error.
+     * @description Useful for custom validation logic or placeholder validators
+     * during development.
+     *
+     * @template T - The type of value
+     * @param {string} error - The error message
+     * @returns {Validator<T>} A validator that always returns failure
+     *
+     * @category Constructors
+     * @example
+     * // Feature flag validation
+     * const validator = featureEnabled
+     *   ? actualValidator
+     *   : Validation.failure('Feature not available');
+     *
+     * @since 2025-07-03
+     */
+    failure: function (error) {
+        return function () {
+            return Result.err(new ValidationError([error]));
+        };
+    },
+    /**
+     * Creates a validator from a predicate function.
+     * @description The fundamental building block for custom validators. Converts
+     * a boolean-returning function into a validator.
+     *
+     * @template T - The type of value to validate
+     * @param {function(T): boolean} predicate - Function that returns true if valid
+     * @param {string} error - Error message if validation fails
+     * @returns {Validator<T>} A validator based on the predicate
+     *
+     * @category Constructors
+     * @example
+     * // Custom age validator
+     * const isAdult = Validation.fromPredicate(
+     *   (age: number) => age >= 18,
+     *   'Must be 18 or older'
+     * );
+     *
+     * @example
+     * // Complex validation
+     * const isValidUsername = Validation.fromPredicate(
+     *   (username: string) => /^[a-zA-Z0-9_]{3,20}$/.test(username),
+     *   'Username must be 3-20 characters, alphanumeric or underscore'
+     * );
+     *
+     * @since 2025-07-03
+     */
+    fromPredicate: function (predicate, error) {
+        return function (value) {
+            return predicate(value)
+                ? Result.ok(value)
+                : Result.err(new ValidationError([error]));
+        };
+    },
+    /**
+     * Combines multiple validators using AND logic.
+     * @description All validators must pass for the validation to succeed.
+     * Collects all errors from all validators before returning, providing
+     * comprehensive feedback.
+     *
+     * @template T - The type of value to validate
+     * @param {Validator<T>[]} validators - Validators to combine
+     * @returns {Validator<T>} A validator that requires all validations to pass
+     *
+     * @category Combinators
+     * @example
+     * // Password validation
+     * const validatePassword = Validation.all(
+     *   validators.string.minLength(8),
+     *   validators.string.matches(/[A-Z]/, 'Must contain uppercase'),
+     *   validators.string.matches(/[0-9]/, 'Must contain number'),
+     *   validators.string.matches(/[!@#$%]/, 'Must contain special character')
+     * );
+     *
+     * @example
+     * // Numeric range validation
+     * const validatePercentage = Validation.all(
+     *   validators.number.min(0),
+     *   validators.number.max(100),
+     *   validators.number.integer()
+     * );
+     *
+     * @since 2025-07-03
+     */
+    all: function () {
+        var validators = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            validators[_i] = arguments[_i];
+        }
+        return function (value) {
+            var errors = [];
+            for (var _i = 0, validators_1 = validators; _i < validators_1.length; _i++) {
+                var validator = validators_1[_i];
+                var result = validator(value);
+                if (!result.success) {
+                    errors.push.apply(errors, result.error.errors);
+                }
+            }
+            return errors.length === 0
+                ? Result.ok(value)
+                : Result.err(new ValidationError(errors));
+        };
+    },
+    /**
+     * Combines multiple validators using OR logic.
+     * @description At least one validator must pass for the validation to succeed.
+     * Returns the result of the first successful validator, or all errors if
+     * none succeed.
+     *
+     * @template T - The type of value to validate
+     * @param {Validator<T>[]} validators - Validators to try
+     * @returns {Validator<T>} A validator that requires at least one validation to pass
+     *
+     * @category Combinators
+     * @example
+     * // Multiple format support
+     * const validateDate = Validation.any(
+     *   validators.string.matches(/^\d{4}-\d{2}-\d{2}$/, 'Invalid ISO date'),
+     *   validators.string.matches(/^\d{2}\/\d{2}\/\d{4}$/, 'Invalid US date')
+     * );
+     *
+     * @example
+     * // Flexible identifier
+     * const validateIdentifier = Validation.any(
+     *   validators.string.matches(/^\d+$/, 'Not a numeric ID'),
+     *   validators.string.email(),
+     *   validators.string.matches(/^[A-Z]{2,}$/, 'Not a code')
+     * );
+     *
+     * @since 2025-07-03
+     */
+    any: function () {
+        var validators = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            validators[_i] = arguments[_i];
+        }
+        return function (value) {
+            var errors = [];
+            for (var _i = 0, validators_2 = validators; _i < validators_2.length; _i++) {
+                var validator = validators_2[_i];
+                var result = validator(value);
+                if (result.success) {
+                    return result;
+                }
+                else {
+                    errors.push.apply(errors, result.error.errors);
+                }
+            }
+            return Result.err(new ValidationError(errors));
+        };
+    },
+    /**
+     * Transforms the validated value if validation passes.
+     * @description Note: The returned validator still takes an input of type T.
+     * This is the functor map operation for validators, allowing value transformation
+     * after successful validation.
+     *
+     * @template T - The input type
+     * @template U - The output type
+     * @param {function(T): U} fn - Function to transform the validated value
+     * @returns {function(Validator<T>): function(T): Result<U, ValidationError>} A function that transforms validators
+     *
+     * @category Transformations
+     * @example
+     * // Normalize email
+     * const normalizeEmail = Validation.map((email: string) => email.toLowerCase());
+     * const validateEmail = normalizeEmail(validators.string.email());
+     *
+     * @example
+     * // Parse and validate
+     * const parseNumber = Validation.map((s: string) => parseInt(s, 10));
+     * const validateNumericString = parseNumber(
+     *   validators.string.matches(/^\d+$/, 'Must be numeric')
+     * );
+     *
+     * @since 2025-07-03
+     */
+    map: function (fn) {
+        return function (validator) {
+            return function (value) {
+                var result = validator(value);
+                return result.success ? Result.ok(fn(result.data)) : result;
+            };
+        };
+    },
+    /**
+     * Chains validators together.
+     * @description The choice of the second validator depends on the successful
+     * result of the first. This is the monadic bind operation for validators,
+     * enabling dynamic validation based on previous results.
+     *
+     * @template T - The type being validated
+     * @param {function(T): Validator<T>} fn - Function that returns the next validator
+     * @returns {function(Validator<T>): Validator<T>} A function that chains validators
+     *
+     * @category Combinators
+     * @example
+     * // Conditional validation based on value
+     * const validateScore = Validation.flatMap((score: number) => {
+     *   if (score < 0) return Validation.failure('Negative scores not allowed');
+     *   if (score > 100) return validators.number.max(200); // Allow bonus points
+     *   return Validation.success();
+     * });
+     *
+     * @example
+     * // Dynamic validation
+     * const validateField = Validation.flatMap((field: { type: string; value: any }) => {
+     *   switch (field.type) {
+     *     case 'email': return validators.string.email();
+     *     case 'number': return validators.number.positive();
+     *     default: return Validation.success();
+     *   }
+     * });
+     *
+     * @since 2025-07-03
+     */
+    flatMap: function (fn) {
+        return function (validator) {
+            return function (value) {
+                var result = validator(value);
+                if (result.success) {
+                    // Get the next validator based on the validated data
+                    var nextValidator = fn(result.data);
+                    // Apply the next validator to the successfully validated data
+                    return nextValidator(result.data);
+                }
+                // For error case, we return the original error
+                return result;
+            };
+        };
+    },
+    /**
+     * Validates an optional value.
+     * @description If the value is null or undefined, validation passes.
+     * Otherwise, applies the validator. Useful for optional form fields
+     * or nullable database columns.
+     *
+     * @template T - The type being validated
+     * @param {Validator<T>} validator - Validator to apply if value is present
+     * @returns {Validator<T | null | undefined>} A validator that handles optional values
+     *
+     * @category Modifiers
+     * @example
+     * // Optional email field
+     * const validateOptionalEmail = Validation.optional(
+     *   validators.string.email()
+     * );
+     *
+     * validateOptionalEmail(null); // => { success: true, data: null }
+     * validateOptionalEmail('user@example.com'); // => validates as email
+     *
+     * @example
+     * // In object schema
+     * const userSchema = schema({
+     *   name: validators.string.nonEmpty(),
+     *   email: validators.string.email(),
+     *   phone: Validation.optional(validators.string.matches(/^\d{10}$/))
+     * });
+     *
+     * @since 2025-07-03
+     */
+    optional: function (validator) {
+        return function (value) {
+            if (value === null || value === undefined) {
+                return Result.ok(value);
+            }
+            return validator(value);
+        };
+    },
+    /**
+     * Makes a validator required.
+     * @description Fails if value is null or undefined. This is a type guard
+     * that narrows T | null | undefined to T.
+     *
+     * @template T - The required type
+     * @param {string} error - Error message if value is missing
+     * @returns {Validator<T | null | undefined>} A validator that requires presence
+     *
+     * @category Modifiers
+     * @example
+     * // Basic usage
+     * const required = Validation.required<string>();
+     * required(null); // => { success: false, error: 'Value is required' }
+     * required('hello'); // => { success: true, data: 'hello' }
+     *
+     * @example
+     * // Combining with other validators
+     * const validateName = Validation.all(
+     *   Validation.required<string>('Name is required'),
+     *   validators.string.minLength(2)
+     * );
+     *
+     * @since 2025-07-03
+     */
+    required: function (error) {
+        if (error === void 0) { error = "Value is required"; }
+        return function (value) {
+            if (value === null || value === undefined) {
+                return Result.err(new ValidationError([error]));
+            }
+            return Result.ok(value);
+        };
+    },
+    /**
+     * Validates each item in an array.
+     * @description Applies the same validator to each element of an array,
+     * collecting all errors with their indices. Returns a new array with
+     * validated (and possibly transformed) items.
+     *
+     * @template T - The type of array elements
+     * @param {Validator<T>} itemValidator - Validator to apply to each item
+     * @returns {Validator<T[]>} A validator for arrays
+     *
+     * @category Collections
+     * @example
+     * // Validate array of emails
+     * const validateEmails = Validation.array(
+     *   validators.string.email()
+     * );
+     *
+     * const result = validateEmails([
+     *   'user@example.com',
+     *   'invalid-email',
+     *   'admin@example.com'
+     * ]);
+     * // Error: "[1]: Invalid email format"
+     *
+     * @example
+     * // Complex item validation
+     * const validateUsers = Validation.array(
+     *   schema({
+     *     name: validators.string.nonEmpty(),
+     *     age: validators.number.positive()
+     *   })
+     * );
+     *
+     * @since 2025-07-03
+     */
+    array: function (itemValidator) {
+        return function (values) {
+            var errors = [];
+            var validatedItems = [];
+            values.forEach(function (value, index) {
+                var result = itemValidator(value);
+                if (result.success) {
+                    validatedItems.push(result.data);
+                }
+                else {
+                    errors.push.apply(errors, result.error.errors.map(function (err) { return "[".concat(index, "]: ").concat(err); }));
+                }
+            });
+            return errors.length === 0
+                ? Result.ok(validatedItems)
+                : Result.err(new ValidationError(errors));
+        };
+    },
+    /**
+     * Validates properties of an object.
+     * @description Validates specified properties of an object using individual
+     * validators. Unspecified properties are passed through unchanged. Errors
+     * are prefixed with the property name for clarity.
+     *
+     * @template T - The object type
+     * @param {object} validators - Map of property names to validators
+     * @returns {Validator<T>} A validator for the object
+     *
+     * @category Objects
+     * @example
+     * // Partial object validation
+     * const validatePerson = Validation.object({
+     *   name: validators.string.nonEmpty(),
+     *   age: validators.number.positive()
+     * });
+     *
+     * const result = validatePerson({
+     *   name: 'John',
+     *   age: -5,
+     *   extra: 'ignored'
+     * });
+     * // Error: "age: Number must be positive"
+     *
+     * @see schema - Type-safe alternative for complete object validation
+     * @since 2025-07-03
+     */
+    object: 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Needed for flexible object validation
+    function (validators) {
+        return function (obj) {
+            var errors = [];
+            var validatedObj = null;
+            var _loop_1 = function (key, validator) {
+                if (validator) {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Type erasure from Object.entries
+                    var result = validator(obj[key]);
+                    if (!result.success) {
+                        errors.push.apply(errors, result.error.errors.map(function (err) { return "".concat(key, ": ").concat(err); }));
+                    }
+                    else if (result.data !== obj[key]) {
+                        // Lazily create a copy only if data is transformed
+                        validatedObj !== null && validatedObj !== void 0 ? validatedObj : (validatedObj = __assign({}, obj));
+                        validatedObj[key] = result.data;
+                    }
+                }
+            };
+            for (var _i = 0, _a = Object.entries(validators); _i < _a.length; _i++) {
+                var _b = _a[_i], key = _b[0], validator = _b[1];
+                _loop_1(key, validator);
+            }
+            return errors.length === 0
+                ? Result.ok(validatedObj !== null && validatedObj !== void 0 ? validatedObj : obj)
+                : Result.err(new ValidationError(errors));
+        };
+    },
+};
+/**
+ * Common validators for primitive types.
+ * @description Pre-built validators for common validation scenarios.
+ * These validators can be used directly or combined with the Validation
+ * combinators to create more complex validation logic.
+ *
+ * @category Validators
+ * @example
+ * // Using validators directly
+ * const emailValidator = validators.string.email();
+ * const ageValidator = validators.number.between(0, 150);
+ *
+ * @example
+ * // Combining validators
+ * const strongPassword = Validation.all(
+ *   validators.string.minLength(12),
+ *   validators.string.matches(/[A-Z]/, 'Need uppercase'),
+ *   validators.string.matches(/[a-z]/, 'Need lowercase'),
+ *   validators.string.matches(/[0-9]/, 'Need number')
+ * );
+ *
+ * @since 2025-07-03
+ */
+export var validators = {
+    /**
+     * String validators.
+     * @description Validators for string values including length checks,
+     * format validation, and pattern matching.
+     *
+     * @category String Validators
+     * @since 2025-07-03
+     */
+    string: {
+        minLength: function (min) {
+            return Validation.fromPredicate(function (str) { return str.length >= min; }, "String must be at least ".concat(min, " characters long"));
+        },
+        maxLength: function (max) {
+            return Validation.fromPredicate(function (str) { return str.length <= max; }, "String must be at most ".concat(max, " characters long"));
+        },
+        nonEmpty: function () {
+            return Validation.fromPredicate(function (str) { return str.trim().length > 0; }, "String cannot be empty");
+        },
+        email: function () {
+            return Validation.fromPredicate(
+            // A more permissive regex, see https://emailregex.com/
+            function (str) { return /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9-]+(?:\.[a-zA-Z0-9-]+)*$/.test(str); }, "Invalid email format");
+        },
+        url: function () {
+            return Validation.fromPredicate(function (str) {
+                try {
+                    new URL(str);
+                    return true;
+                }
+                catch (_a) {
+                    return false;
+                }
+            }, "Invalid URL format");
+        },
+        matches: function (pattern, error) {
+            if (error === void 0) { error = "String does not match pattern"; }
+            return Validation.fromPredicate(function (str) { return pattern.test(str); }, error);
+        },
+        oneOf: function (options) {
+            return Validation.fromPredicate(function (str) { return options.includes(str); }, "String must be one of: ".concat(options.join(", ")));
+        },
+    },
+    /**
+     * Number validators.
+     */
+    number: {
+        min: function (min) {
+            return Validation.fromPredicate(function (num) { return num >= min; }, "Number must be at least ".concat(min));
+        },
+        max: function (max) {
+            return Validation.fromPredicate(function (num) { return num <= max; }, "Number must be at most ".concat(max));
+        },
+        positive: function () {
+            return Validation.fromPredicate(function (num) { return num > 0; }, "Number must be positive");
+        },
+        nonNegative: function () {
+            return Validation.fromPredicate(function (num) { return num >= 0; }, "Number must be non-negative");
+        },
+        integer: function () {
+            return Validation.fromPredicate(function (num) { return Number.isInteger(num); }, "Number must be an integer");
+        },
+        between: function (min, max) {
+            return Validation.fromPredicate(function (num) { return num >= min && num <= max; }, "Number must be between ".concat(min, " and ").concat(max));
+        },
+    },
+    /**
+     * Array validators.
+     */
+    array: {
+        minLength: function (min) {
+            return Validation.fromPredicate(function (arr) { return arr.length >= min; }, "Array must have at least ".concat(min, " items"));
+        },
+        maxLength: function (max) {
+            return Validation.fromPredicate(function (arr) { return arr.length <= max; }, "Array must have at most ".concat(max, " items"));
+        },
+        nonEmpty: function () {
+            return Validation.fromPredicate(function (arr) { return arr.length > 0; }, "Array cannot be empty");
+        },
+        unique: function () {
+            return Validation.fromPredicate(function (arr) { return new Set(arr).size === arr.length; }, "Array must contain unique items");
+        },
+    },
+    /**
+     * Date validators.
+     */
+    date: {
+        after: function (date) {
+            return Validation.fromPredicate(function (d) { return d > date; }, "Date must be after ".concat(date.toISOString()));
+        },
+        before: function (date) {
+            return Validation.fromPredicate(function (d) { return d < date; }, "Date must be before ".concat(date.toISOString()));
+        },
+        future: function () {
+            return Validation.fromPredicate(function (d) { return d > new Date(); }, "Date must be in the future");
+        },
+        past: function () {
+            return Validation.fromPredicate(function (d) { return d < new Date(); }, "Date must be in the past");
+        },
+    },
+    /**
+     * Object validators.
+     */
+    object: {
+        hasProperty: function (prop) {
+            return Validation.fromPredicate(function (obj) { return prop in obj; }, "Object must have property '".concat(String(prop), "'"));
+        },
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Flexible for any object type
+        notEmpty: function () {
+            return Validation.fromPredicate(
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Matches return type
+            function (obj) { return Object.keys(obj).length > 0; }, "Object cannot be empty");
+        },
+    },
+};
+/**
+ * Utility for creating complex validation schemas.
+ * @description Type-safe wrapper around Validation.object that requires
+ * validators for all properties of the type. This ensures complete
+ * validation coverage for object types.
+ *
+ * @template T - The object type to validate
+ * @param {object} validators - Validators for each property of T
+ * @returns {Validator<T>} A validator for objects of type T
+ *
+ * @category Schema
+ * @example
+ * // Type-safe user validation
+ * interface User {
+ *   name: string;
+ *   email: string;
+ *   age: number;
+ * }
+ *
+ * const userValidator = schema<User>({
+ *   name: validators.string.nonEmpty(),
+ *   email: validators.string.email(),
+ *   age: validators.number.between(0, 150)
+ * });
+ *
+ * @example
+ * // Nested schemas
+ * const addressValidator = schema({
+ *   street: validators.string.nonEmpty(),
+ *   city: validators.string.nonEmpty(),
+ *   zipCode: validators.string.matches(/^\d{5}$/)
+ * });
+ *
+ * const personValidator = schema({
+ *   name: validators.string.nonEmpty(),
+ *   address: addressValidator
+ * });
+ *
+ * @since 2025-07-03
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- Needed for flexible object validation
+export var schema = function (validators) { return Validation.object(validators); };
+/**
+ * Validates a value and returns either the validated value or throws the error.
+ * @description Use sparingly, only when you're certain validation should pass.
+ * This bridges the Result-based validation system with exception-based code.
+ *
+ * @template T - The type being validated
+ * @param {Validator<T>} validator - The validator to apply
+ * @returns {function(T): T} A function that validates or throws
+ * @throws {ValidationError} If validation fails
+ *
+ * @category Utilities
+ * @example
+ * // Configuration validation at startup
+ * const validateConfig = validateOrThrow(
+ *   schema({
+ *     port: validators.number.between(1, 65535),
+ *     host: validators.string.nonEmpty()
+ *   })
+ * );
+ *
+ * // Throws if invalid, otherwise returns validated config
+ * const config = validateConfig(loadConfig());
+ *
+ * @example
+ * // Input sanitization
+ * const sanitizeEmail = validateOrThrow(
+ *   Validation.map((s: string) => s.toLowerCase())(
+ *     validators.string.email()
+ *   )
+ * );
+ *
+ * @since 2025-07-03
+ */
+export var validateOrThrow = function (validator) {
+    return function (value) {
+        var result = validator(value);
+        if (result.success) {
+            return result.data;
+        }
+        else {
+            throw result.error;
+        }
+    };
+};
+//# sourceMappingURL=validation.mjs.map