umt 3.0.0 → 3.2.0

package/module/es5/Validate/any/core.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.any = void 0;
+var _standardSchema = require("../../Validate/standardSchema");
 /**
  * Any validation core module
  * Provides a validator that accepts any value, useful when a position in a
@@ -25,12 +26,12 @@ var anyValidator = function anyValidator(_value) {
     type: "any"
   };
 };
+var standardAnyValidator = (0, _standardSchema.attachStandard)(anyValidator);
 
 /**
  * Creates a validator that accepts any value
  * @returns {Function} - Validator that always succeeds
  */
-// biome-ignore lint/suspicious/noExplicitAny: any() must accept and infer any value
 var any = exports.any = function any() {
-  return anyValidator;
+  return standardAnyValidator;
 };

package/module/es5/Validate/array/arrayOf.d.ts

@@ -1,5 +1,6 @@
+import { type StandardSchemaV1 } from "../../Validate/standardSchema";
 import type { ValidateCoreReturnType, ValidateType } from "../../Validate/type";
-type ExtractValidatedType<V> = V extends (value: never) => {
+export type ArrayOfExtractValidatedType<V> = V extends (value: never) => {
     type: infer T;
 } ? ValidateType<T> : never;
 /**
@@ -13,5 +14,4 @@ export declare const arrayOf: <V extends (value: never) => {
     type: unknown;
     message: string;
     validate: boolean;
-}>(validator: V, message?: string) => (values: ExtractValidatedType<V>[]) => ValidateCoreReturnType<ExtractValidatedType<V>[]>;
-export {};
+}>(validator: V, message?: string) => ((values: ArrayOfExtractValidatedType<V>[]) => ValidateCoreReturnType<ArrayOfExtractValidatedType<V>[]>) & StandardSchemaV1<ArrayOfExtractValidatedType<V>[], ArrayOfExtractValidatedType<V>[]>;

package/module/es5/Validate/array/arrayOf.js

@@ -5,6 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.arrayOf = void 0;
 var _isArray = require("../../Validate/isArray");
+var _standardSchema = require("../../Validate/standardSchema");
 function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
 function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
 function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
@@ -22,7 +23,7 @@ function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length)
  * @returns {Function} - Validator function for arrays whose elements satisfy the given validator
  */
 var arrayOf = exports.arrayOf = function arrayOf(validator, message) {
-  return function (values) {
+  var arrayValidator = function arrayValidator(values) {
     if (!(0, _isArray.isArray)(values)) {
       return {
         validate: false,
@@ -55,4 +56,5 @@ var arrayOf = exports.arrayOf = function arrayOf(validator, message) {
       type: values
     };
   };
+  return (0, _standardSchema.attachStandard)(arrayValidator);
 };

package/module/es5/Validate/bigint/core.d.ts

@@ -2,6 +2,7 @@
  * BigInt validation core module
  * Provides the base validation functionality for bigint values
  */
+import { type StandardSchemaV1 } from "../../Validate/standardSchema";
 import type { ValidateReturnType } from "../../Validate/type";
 /**
  * Return type produced by a `bigint` validator. Structurally compatible with
@@ -21,4 +22,4 @@ export interface BigIntReturnType {
  * @param {string} [message] - Custom error message for type validation
  * @returns {Function} - Validator function that checks if the value is a bigint and applies validation rules
  */
-export declare const bigint: <T extends ValidateReturnType<bigint>[]>(option?: T, message?: string) => (value: bigint) => BigIntReturnType;
+export declare const bigint: <T extends ValidateReturnType<bigint>[]>(option?: T, message?: string) => ((value: bigint) => BigIntReturnType) & StandardSchemaV1<bigint, bigint>;

package/module/es5/Validate/bigint/core.js

@@ -4,14 +4,13 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.bigint = void 0;
+var _standardSchema = require("../../Validate/standardSchema");
 function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
 function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
-function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
-/**
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; } /**
  * BigInt validation core module
  * Provides the base validation functionality for bigint values
  */
-
 /**
  * Return type produced by a `bigint` validator. Structurally compatible with
  * `ValidateCoreReturnType<bigint>`, but exposes the literal `"bigint"` tag
@@ -29,7 +28,7 @@ function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length)
 var bigint = exports.bigint = function bigint() {
   var option = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
   var message = arguments.length > 1 ? arguments[1] : undefined;
-  return function (value) {
+  var validator = function validator(value) {
     if (typeof value !== "bigint") {
       return {
         validate: false,
@@ -62,4 +61,5 @@ var bigint = exports.bigint = function bigint() {
       type: "bigint"
     };
   };
+  return (0, _standardSchema.attachStandard)(validator);
 };

package/module/es5/Validate/boolean/core.d.ts

@@ -2,10 +2,11 @@
  * Boolean validation core module
  * Provides the base validation functionality for boolean values
  */
+import { type StandardSchemaV1 } from "../../Validate/standardSchema";
 import type { ValidateCoreReturnType } from "../../Validate/type";
 /**
  * Creates a boolean validator
  * @param {string} [message] - Custom error message for type validation
  * @returns {Function} - Validator function that checks if the value is a boolean
  */
-export declare const boolean: (message?: string) => (value: boolean) => ValidateCoreReturnType<boolean>;
+export declare const boolean: (message?: string) => ((value: boolean) => ValidateCoreReturnType<boolean>) & StandardSchemaV1<boolean, boolean>;

package/module/es5/Validate/boolean/core.js

@@ -5,6 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports["boolean"] = void 0;
 var _core = require("../../Validate/core");
+var _standardSchema = require("../../Validate/standardSchema");
 /**
  * Boolean validation core module
  * Provides the base validation functionality for boolean values
@@ -16,7 +17,8 @@ var _core = require("../../Validate/core");
  * @returns {Function} - Validator function that checks if the value is a boolean
  */
 var _boolean = exports["boolean"] = function _boolean(message) {
-  return function (value) {
+  var validator = function validator(value) {
     return (0, _core.core)("boolean")(value, [], message);
   };
+  return (0, _standardSchema.attachStandard)(validator);
 };

package/module/es5/Validate/date/core.d.ts

@@ -2,6 +2,7 @@
  * Date validation core module
  * Provides the base validation functionality for Date instances
  */
+import { type StandardSchemaV1 } from "../../Validate/standardSchema";
 import type { ValidateCoreReturnType } from "../../Validate/type";
 /**
  * Creates a Date validator. The validator checks both that the value is an
@@ -11,4 +12,4 @@ import type { ValidateCoreReturnType } from "../../Validate/type";
  * @param {string} [message] - Custom error message for type validation
  * @returns {Function} - Validator function that checks if the value is a Date instance
  */
-export declare const date: (message?: string) => (value: Date) => ValidateCoreReturnType<Date>;
+export declare const date: (message?: string) => ((value: Date) => ValidateCoreReturnType<Date>) & StandardSchemaV1<Date, Date>;

package/module/es5/Validate/date/core.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.date = void 0;
+var _standardSchema = require("../../Validate/standardSchema");
 /**
  * Date validation core module
  * Provides the base validation functionality for Date instances
@@ -18,7 +19,7 @@ exports.date = void 0;
  * @returns {Function} - Validator function that checks if the value is a Date instance
  */
 var date = exports.date = function date(message) {
-  return function (value) {
+  var validator = function validator(value) {
     if (!(value instanceof Date) || Number.isNaN(value.getTime())) {
       return {
         validate: false,
@@ -32,4 +33,5 @@ var date = exports.date = function date(message) {
       type: value
     };
   };
+  return (0, _standardSchema.attachStandard)(validator);
 };

package/module/es5/Validate/file/core.d.ts

@@ -3,6 +3,7 @@
  * Provides validation for File / Blob instances. Falls back to `Blob` when
  * the global `File` constructor is unavailable.
  */
+import { type StandardSchemaV1 } from "../../Validate/standardSchema";
 import type { ValidateCoreReturnType } from "../../Validate/type";
 /**
  * Creates a validator that checks whether a value is a `File` (or `Blob` in
@@ -10,4 +11,4 @@ import type { ValidateCoreReturnType } from "../../Validate/type";
  * @param {string} [message] - Custom error message for type validation
  * @returns {Function} - Validator function for File / Blob instances
  */
-export declare const file: (message?: string) => (value: File) => ValidateCoreReturnType<File>;
+export declare const file: (message?: string) => ((value: File) => ValidateCoreReturnType<File>) & StandardSchemaV1<File, File>;

package/module/es5/Validate/file/core.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.file = void 0;
+var _standardSchema = require("../../Validate/standardSchema");
 /**
  * File validation core module
  * Provides validation for File / Blob instances. Falls back to `Blob` when
@@ -20,7 +21,7 @@ var hasBlobConstructor = typeof Blob !== "undefined";
  * @returns {Function} - Validator function for File / Blob instances
  */
 var file = exports.file = function file(message) {
-  return function (value) {
+  var validator = function validator(value) {
     var isFile = hasFileConstructor && value instanceof File;
     var isBlob = hasBlobConstructor && value instanceof Blob;
     if (!(isFile || isBlob)) {
@@ -36,4 +37,5 @@ var file = exports.file = function file(message) {
       type: value
     };
   };
+  return (0, _standardSchema.attachStandard)(validator);
 };

package/module/es5/Validate/function/core.d.ts

@@ -10,28 +10,29 @@
  * `implement` property directly) to create a wrapped function that asserts
  * the schema on every call.
  */
+import { type StandardSchemaV1 } from "../../Validate/standardSchema";
 import type { ValidateCoreReturnType, ValidateType } from "../../Validate/type";
-type AnyValidator = (value: any) => ValidateCoreReturnType<unknown>;
-type ExtractValidatedType<V> = V extends (value: never) => {
+export type FunctionAnyValidator = (value: any) => ValidateCoreReturnType<unknown>;
+export type FunctionExtractValidatedType<V> = V extends (value: never) => {
     type: infer T;
 } ? ValidateType<T> : never;
-type InferInputs<Inputs> = Inputs extends readonly AnyValidator[] ? {
-    [K in keyof Inputs]: ExtractValidatedType<Inputs[K]>;
+export type InferInputs<Inputs> = Inputs extends readonly FunctionAnyValidator[] ? {
+    [K in keyof Inputs]: FunctionExtractValidatedType<Inputs[K]>;
 } : any[];
-type InferOutput<Output> = Output extends AnyValidator ? ExtractValidatedType<Output> : any;
+export type InferOutput<Output> = Output extends FunctionAnyValidator ? FunctionExtractValidatedType<Output> : any;
 /**
  * Function schema definition. `input` describes positional parameters and
  * `output` describes the return type. Both are optional; when omitted the
  * validator only enforces that the value is callable.
  */
 export interface FunctionSchema {
-    input?: readonly AnyValidator[];
-    output?: AnyValidator;
+    input?: readonly FunctionAnyValidator[];
+    output?: FunctionAnyValidator;
 }
-type ExtractInput<S> = S extends {
+export type ExtractInput<S> = S extends {
     input: infer I;
 } ? I : undefined;
-type ExtractOutput<S> = S extends {
+export type ExtractOutput<S> = S extends {
     output: infer O;
 } ? O : undefined;
 /**
@@ -71,5 +72,4 @@ export interface FunctionValidator<Inputs, Output> {
  * @param {string} [message] - Custom error message for type validation
  * @returns {FunctionValidator} - Validator augmented with `implement()`
  */
-export declare const function_: <const S extends FunctionSchema = FunctionSchema>(schema?: S, message?: string) => FunctionValidator<ExtractInput<S>, ExtractOutput<S>>;
-export {};
+export declare const function_: <const S extends FunctionSchema = FunctionSchema>(schema?: S, message?: string) => FunctionValidator<ExtractInput<S>, ExtractOutput<S>> & StandardSchemaV1<InferFunction<ExtractInput<S>, ExtractOutput<S>>, InferFunction<ExtractInput<S>, ExtractOutput<S>>>;

package/module/es5/Validate/function/core.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.function_ = void 0;
+var _standardSchema = require("../../Validate/standardSchema");
 function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
 function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
 function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
@@ -14,8 +15,7 @@ function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" !=
 function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
 function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
 function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
-function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
-/**
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; } /**
  * Function validation core module
  * Provides a validator for function values along with an `implement()`
  * helper that wraps a concrete function with runtime validation of its
@@ -27,9 +27,6 @@ function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length)
  * `implement` property directly) to create a wrapped function that asserts
  * the schema on every call.
  */
-
-// biome-ignore lint/suspicious/noExplicitAny: validator signatures vary
-
 /**
  * Function schema definition. `input` describes positional parameters and
  * `output` describes the return type. Both are optional; when omitted the
@@ -121,5 +118,5 @@ var function_ = exports.function_ = function function_(schema, message) {
     };
     return wrapped;
   };
-  return validator;
+  return (0, _standardSchema.attachStandard)(validator);
 };

package/module/es5/Validate/index.d.ts

@@ -11,6 +11,7 @@ export * from "./never";
 export * from "./number";
 export * from "./object";
 export * from "./set";
+export * from "./standardSchema";
 export * from "./string";
 export * from "./templateLiteral";
 export * from "./type";

package/module/es5/Validate/index.js

@@ -146,6 +146,17 @@ Object.keys(_set).forEach(function (key) {
     }
   });
 });
+var _standardSchema = require("./standardSchema");
+Object.keys(_standardSchema).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _standardSchema[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _standardSchema[key];
+    }
+  });
+});
 var _string = require("./string");
 Object.keys(_string).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;

package/module/es5/Validate/instanceof/core.d.ts

@@ -4,8 +4,9 @@
  * specific constructor, including subclasses. The validator is exported as
  * `instanceof_` because `instanceof` is a reserved keyword in JavaScript.
  */
+import { type StandardSchemaV1 } from "../../Validate/standardSchema";
 import type { ValidateCoreReturnType } from "../../Validate/type";
-type Constructor<T> = new (...arguments_: any[]) => T;
+export type Constructor<T> = new (...arguments_: any[]) => T;
 /**
  * Creates a validator that checks whether a value is an instance of the given
  * constructor. Subclasses of the constructor satisfy the validator, matching
@@ -15,5 +16,4 @@ type Constructor<T> = new (...arguments_: any[]) => T;
  * @param {string} [message] - Custom error message for validation failure
  * @returns {Function} - Validator function for instances of the constructor
  */
-export declare const instanceof_: <T>(classConstructor: Constructor<T>, message?: string) => (value: T) => ValidateCoreReturnType<T>;
-export {};
+export declare const instanceof_: <T>(classConstructor: Constructor<T>, message?: string) => ((value: T) => ValidateCoreReturnType<T>) & StandardSchemaV1<T, T>;

package/module/es5/Validate/instanceof/core.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.instanceof_ = void 0;
+var _standardSchema = require("../../Validate/standardSchema");
 /**
  * instanceof validation core module
  * Provides a validator that checks whether a value is an instance of a
@@ -23,7 +24,7 @@ exports.instanceof_ = void 0;
  * @returns {Function} - Validator function for instances of the constructor
  */
 var instanceof_ = exports.instanceof_ = function instanceof_(classConstructor, message) {
-  return function (value) {
+  var validator = function validator(value) {
     if (!(value instanceof classConstructor)) {
       return {
         validate: false,
@@ -37,4 +38,5 @@ var instanceof_ = exports.instanceof_ = function instanceof_(classConstructor, m
       type: value
     };
   };
+  return (0, _standardSchema.attachStandard)(validator);
 };

package/module/es5/Validate/map/core.d.ts

@@ -4,8 +4,9 @@
  * delegate to per-entry validators for keys and values, mirroring how
  * `arrayOf()` validates each element of an array.
  */
+import { type StandardSchemaV1 } from "../../Validate/standardSchema";
 import type { ValidateCoreReturnType, ValidateType } from "../../Validate/type";
-type ExtractValidatedType<V> = V extends (value: never) => {
+export type MapExtractValidatedType<V> = V extends (value: never) => {
     type: infer T;
 } ? ValidateType<T> : never;
 /**
@@ -20,5 +21,4 @@ type ExtractValidatedType<V> = V extends (value: never) => {
  * @param {string} [message] - Custom error message for type validation
  * @returns {Function} - Validator function for Map instances
  */
-export declare const map: <KV extends (value: any) => ValidateCoreReturnType<unknown> = (value: unknown) => ValidateCoreReturnType<unknown>, VV extends (value: any) => ValidateCoreReturnType<unknown> = (value: unknown) => ValidateCoreReturnType<unknown>, K = ExtractValidatedType<KV>, V = ExtractValidatedType<VV>>(keyValidator?: KV, valueValidator?: VV, message?: string) => (value: Map<K, V>) => ValidateCoreReturnType<Map<K, V>>;
-export {};
+export declare const map: <KV extends (value: any) => ValidateCoreReturnType<unknown> = (value: unknown) => ValidateCoreReturnType<unknown>, VV extends (value: any) => ValidateCoreReturnType<unknown> = (value: unknown) => ValidateCoreReturnType<unknown>, K = MapExtractValidatedType<KV>, V = MapExtractValidatedType<VV>>(keyValidator?: KV, valueValidator?: VV, message?: string) => ((value: Map<K, V>) => ValidateCoreReturnType<Map<K, V>>) & StandardSchemaV1<Map<K, V>, Map<K, V>>;

package/module/es5/Validate/map/core.js

@@ -4,20 +4,19 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.map = void 0;
+var _standardSchema = require("../../Validate/standardSchema");
 function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
 function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
 function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
 function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
 function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
 function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
-function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
-/**
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; } /**
  * Map validation core module
  * Provides validation for `Map` instances. The validator can optionally
  * delegate to per-entry validators for keys and values, mirroring how
  * `arrayOf()` validates each element of an array.
  */
-
 /**
  * Creates a Map validator. The validator can optionally accept per-entry key
  * and value validators that are applied to every entry of the map. When the
@@ -31,7 +30,7 @@ function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length)
  * @returns {Function} - Validator function for Map instances
  */
 var map = exports.map = function map(keyValidator, valueValidator, message) {
-  return function (value) {
+  var mapValidator = function mapValidator(value) {
     if (!(value instanceof Map)) {
       return {
         validate: false,
@@ -78,4 +77,5 @@ var map = exports.map = function map(keyValidator, valueValidator, message) {
       type: value
     };
   };
+  return (0, _standardSchema.attachStandard)(mapValidator);
 };

package/module/es5/Validate/never/core.d.ts

@@ -4,6 +4,7 @@
  * positions in a schema that must never be filled (for example, exhaustive
  * union members that should be unreachable at the type level).
  */
+import { type StandardSchemaV1 } from "../../Validate/standardSchema";
 /**
  * Return type produced by a `never` validator. Exposes the literal `"never"`
  * tag through the `type` field so `ValidateType<"never">` can map it back to
@@ -19,4 +20,4 @@ export interface NeverReturnType {
  * @param {string} [message] - Custom error message for validation failure
  * @returns {Function} - Validator that always returns a failing result
  */
-export declare const never: (message?: string) => ((value: any) => NeverReturnType);
+export declare const never: (message?: string) => ((value: any) => NeverReturnType) & StandardSchemaV1<never, never>;

package/module/es5/Validate/never/core.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.never = void 0;
+var _standardSchema = require("../../Validate/standardSchema");
 /**
  * Never validation core module
  * Provides a validator that fails for every input, useful for marking
@@ -22,14 +23,14 @@ exports.never = void 0;
  * @param {string} [message] - Custom error message for validation failure
  * @returns {Function} - Validator that always returns a failing result
  */
-// biome-ignore lint/suspicious/noExplicitAny: never() is widened to accept any input from union/intersection
 var never = exports.never = function never(message) {
   // biome-ignore lint/suspicious/noExplicitAny: signature mirrors the public type
-  return function (_value) {
+  var neverValidator = function neverValidator(_value) {
     return {
       validate: false,
       message: message !== null && message !== void 0 ? message : "",
       type: "never"
     };
   };
+  return (0, _standardSchema.attachStandard)(neverValidator);
 };

package/module/es5/Validate/number/core.d.ts

@@ -2,7 +2,8 @@
  * Number validation core module
  * Provides the base validation functionality for number values
  */
-import type { ValidateReturnType } from "../../Validate/type";
+import { type StandardSchemaV1 } from "../../Validate/standardSchema";
+import type { ValidateCoreReturnType, ValidateReturnType } from "../../Validate/type";
 /**
  * Creates a number validator with optional validation rules
  * @template T - Array of validation rules for numbers
@@ -10,4 +11,4 @@ import type { ValidateReturnType } from "../../Validate/type";
  * @param {string} [message] - Custom error message for type validation
  * @returns {Function} - Validator function that checks if the value is a number and applies validation rules
  */
-export declare const number: <T extends ValidateReturnType<number>[]>(option?: T, message?: string) => (value: number) => import("../../Validate/type").ValidateCoreReturnType<number>;
+export declare const number: <T extends ValidateReturnType<number>[]>(option?: T, message?: string) => ((value: number) => ValidateCoreReturnType<number>) & StandardSchemaV1<number, number>;

package/module/es5/Validate/number/core.js

@@ -5,6 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.number = void 0;
 var _core = require("../../Validate/core");
+var _standardSchema = require("../../Validate/standardSchema");
 /**
  * Number validation core module
  * Provides the base validation functionality for number values
@@ -18,7 +19,8 @@ var _core = require("../../Validate/core");
  * @returns {Function} - Validator function that checks if the value is a number and applies validation rules
  */
 var number = exports.number = function number(option, message) {
-  return function (value) {
+  var validator = function validator(value) {
     return (0, _core.core)("number")(value, option, message);
   };
+  return (0, _standardSchema.attachStandard)(validator);
 };

package/module/es5/Validate/object/core.d.ts

@@ -3,6 +3,7 @@
  * Provides validation functionality for objects with type-specific validation rules for each property
  */
 import type { PickPartial } from "../../types/object";
+import { type StandardSchemaV1 } from "../../Validate/standardSchema";
 import type { OptionalKeys, ValidateCoreReturnType, ValidateType } from "../../Validate/type";
 /**
  * Shape map describing per-property validators consumed by `object()`
@@ -31,4 +32,4 @@ export type ObjectValidator<T extends ObjectShape, U = {
  * @param {string} [message] - Custom error message for object type validation
  * @returns {ObjectValidator<T>} - Validator function with `.shape` attached so it can compose with `pick()`, `omit()`, `partial()`, and `required()`
  */
-export declare const object: <T extends ObjectShape>(option?: T, message?: string) => ObjectValidator<T>;
+export declare const object: <T extends ObjectShape>(option?: T, message?: string) => ObjectValidator<T> & StandardSchemaV1<unknown, unknown>;

package/module/es5/Validate/object/core.js

@@ -5,6 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.object = void 0;
 var _isDictionaryObject = require("../../Validate/isDictionaryObject");
+var _standardSchema = require("../../Validate/standardSchema");
 /**
  * Object validation core module
  * Provides validation functionality for objects with type-specific validation rules for each property
@@ -58,5 +59,5 @@ var object = exports.object = function object() {
     };
   };
   validator.shape = option;
-  return validator;
+  return (0, _standardSchema.attachStandard)(validator);
 };

package/module/es5/Validate/object/intersection.d.ts

@@ -1,15 +1,15 @@
+import { type StandardSchemaV1 } from "../../Validate/standardSchema";
 import type { ValidateCoreReturnType, ValidateType } from "../../Validate/type";
-type ExtractValidatedType<V> = V extends (value: never) => {
+export type IntersectionExtractValidatedType<V> = V extends (value: never) => {
     type: infer T;
 } ? ValidateType<T> : never;
-type IntersectValidatedTypes<Vs> = Vs extends readonly [
+export type IntersectValidatedTypes<Vs> = Vs extends readonly [
     infer Head,
     ...infer Tail
-] ? ExtractValidatedType<Head> & IntersectValidatedTypes<Tail> : unknown;
+] ? IntersectionExtractValidatedType<Head> & IntersectValidatedTypes<Tail> : unknown;
 /**
  * Creates an intersection validator that passes only if all given validators pass
  * @param validators - Validator functions to compose as an intersection (logical AND)
  * @returns {Function} - Validator that checks if the value matches all validators
  */
-export declare const intersection: <Vs extends ((value: never) => ValidateCoreReturnType<unknown>)[]>(...validators: [...Vs]) => (value: IntersectValidatedTypes<Vs>) => ValidateCoreReturnType<IntersectValidatedTypes<Vs>>;
-export {};
+export declare const intersection: <Vs extends ((value: never) => ValidateCoreReturnType<unknown>)[]>(...validators: [...Vs]) => ((value: IntersectValidatedTypes<Vs>) => ValidateCoreReturnType<IntersectValidatedTypes<Vs>>) & StandardSchemaV1<IntersectValidatedTypes<Vs>, IntersectValidatedTypes<Vs>>;

package/module/es5/Validate/object/intersection.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.intersection = void 0;
+var _standardSchema = require("../../Validate/standardSchema");
 // Extract the validated value type by reading the validator's `type` field
 // (and applying `ValidateType` to map type tags like "string" back to the
 // runtime type). Reading the field directly lets validators that expose the
@@ -25,7 +26,7 @@ var intersection = exports.intersection = function intersection() {
   for (var _len = arguments.length, validators = new Array(_len), _key = 0; _key < _len; _key++) {
     validators[_key] = arguments[_key];
   }
-  return function (value) {
+  var intersectionValidator = function intersectionValidator(value) {
     for (var _i = 0, _validators = validators; _i < _validators.length; _i++) {
       var validator = _validators[_i];
       var result = validator(value);
@@ -43,4 +44,5 @@ var intersection = exports.intersection = function intersection() {
       type: value
     };
   };
+  return (0, _standardSchema.attachStandard)(intersectionValidator);
 };

package/module/es5/Validate/object/nullable.d.ts

@@ -1,4 +1,5 @@
-interface NullReturn {
+import { type StandardSchemaV1 } from "../../Validate/standardSchema";
+export interface NullReturn {
     validate: boolean;
     message: string;
     type: "null";
@@ -14,5 +15,4 @@ export declare const nullable: <T, R extends {
     type: unknown;
     message: string;
     validate: boolean;
-}>(validator: (value: T) => R) => ((value: T | null) => R | NullReturn);
-export {};
+}>(validator: (value: T) => R) => ((value: T | null) => R | NullReturn) & StandardSchemaV1<T | null, T | null>;

package/module/es5/Validate/object/nullable.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.nullable = void 0;
+var _standardSchema = require("../../Validate/standardSchema");
 /**
  * Wraps a validator to accept null values
  * @template T - The type of value the wrapped validator expects
@@ -22,5 +23,5 @@ var nullable = exports.nullable = function nullable(validator) {
     }
     return validator(value);
   };
-  return nullableValidator;
+  return (0, _standardSchema.attachStandard)(nullableValidator);
 };

package/module/es5/Validate/object/optional.d.ts

@@ -1,4 +1,5 @@
-interface UndefinedReturn {
+import { type StandardSchemaV1 } from "../../Validate/standardSchema";
+export interface UndefinedReturn {
     validate: boolean;
     message: string;
     type: "undefined";
@@ -32,5 +33,4 @@ export declare const optional: <T, R extends {
     type: unknown;
     message: string;
     validate: boolean;
-}>(validator: (value: T) => R) => OptionalValidator<T, R>;
-export {};
+}>(validator: (value: T) => R) => OptionalValidator<T, R> & StandardSchemaV1<T | undefined, T | undefined>;