umt 3.1.0 → 3.2.0

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,6 +10,7 @@
  * `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";
 export type FunctionAnyValidator = (value: any) => ValidateCoreReturnType<unknown>;
 export type FunctionExtractValidatedType<V> = V extends (value: never) => {
@@ -71,4 +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 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,7 +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.
  */
-
 /**
  * Function schema definition. `input` describes positional parameters and
  * `output` describes the return type. Both are optional; when omitted the
@@ -119,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,6 +4,7 @@
  * 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";
 export type Constructor<T> = new (...arguments_: any[]) => T;
 /**
@@ -15,4 +16,4 @@ export 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 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,6 +4,7 @@
  * 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";
 export type MapExtractValidatedType<V> = V extends (value: never) => {
     type: infer T;
@@ -20,4 +21,4 @@ export type MapExtractValidatedType<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 = MapExtractValidatedType<KV>, V = MapExtractValidatedType<VV>>(keyValidator?: KV, valueValidator?: VV, message?: string) => (value: Map<K, V>) => ValidateCoreReturnType<Map<K, V>>;
+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,3 +1,4 @@
+import { type StandardSchemaV1 } from "../../Validate/standardSchema";
 import type { ValidateCoreReturnType, ValidateType } from "../../Validate/type";
 export type IntersectionExtractValidatedType<V> = V extends (value: never) => {
     type: infer T;
@@ -11,4 +12,4 @@ export type IntersectValidatedTypes<Vs> = Vs extends readonly [
  * @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 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,3 +1,4 @@
+import { type StandardSchemaV1 } from "../../Validate/standardSchema";
 export interface NullReturn {
     validate: boolean;
     message: string;
@@ -14,4 +15,4 @@ export declare const nullable: <T, R extends {
     type: unknown;
     message: string;
     validate: boolean;
-}>(validator: (value: T) => R) => ((value: T | null) => R | NullReturn);
+}>(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,3 +1,4 @@
+import { type StandardSchemaV1 } from "../../Validate/standardSchema";
 export interface UndefinedReturn {
     validate: boolean;
     message: string;
@@ -32,4 +33,4 @@ export declare const optional: <T, R extends {
     type: unknown;
     message: string;
     validate: boolean;
-}>(validator: (value: T) => R) => OptionalValidator<T, R>;
+}>(validator: (value: T) => R) => OptionalValidator<T, R> & StandardSchemaV1<T | undefined, T | undefined>;

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

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.optional = void 0;
+var _standardSchema = require("../../Validate/standardSchema");
 /**
  * Optional validator augmented with a reference to the wrapped validator,
  * used by `required()` to unwrap optional layers when rebuilding a shape
@@ -31,5 +32,5 @@ var optional = exports.optional = function optional(validator) {
   };
   optionalValidator.inner = validator;
   optionalValidator.isOptional = true;
-  return optionalValidator;
+  return (0, _standardSchema.attachStandard)(optionalValidator);
 };

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

@@ -1,3 +1,4 @@
+import { type StandardSchemaV1 } from "../../Validate/standardSchema";
 import type { ValidateCoreReturnType, ValidateType } from "../../Validate/type";
 export type UnionExtractValidatedType<V> = V extends (value: never) => {
     type: infer T;
@@ -7,4 +8,4 @@ export type UnionExtractValidatedType<V> = V extends (value: never) => {
  * @param validators - Validator functions to compose as a union (logical OR)
  * @returns {Function} - Validator that checks if the value matches any of the validators
  */
-export declare const union: <Vs extends ((value: never) => ValidateCoreReturnType<unknown>)[]>(...validators: [...Vs]) => (value: UnionExtractValidatedType<Vs[number]>) => ValidateCoreReturnType<UnionExtractValidatedType<Vs[number]>>;
+export declare const union: <Vs extends ((value: never) => ValidateCoreReturnType<unknown>)[]>(...validators: [...Vs]) => ((value: UnionExtractValidatedType<Vs[number]>) => ValidateCoreReturnType<UnionExtractValidatedType<Vs[number]>>) & StandardSchemaV1<UnionExtractValidatedType<Vs[number]>, UnionExtractValidatedType<Vs[number]>>;

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

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.union = 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
@@ -19,7 +20,7 @@ var union = exports.union = function union() {
   for (var _len = arguments.length, validators = new Array(_len), _key = 0; _key < _len; _key++) {
     validators[_key] = arguments[_key];
   }
-  return function (value) {
+  var unionValidator = function unionValidator(value) {
     var lastMessage = "";
     for (var _i = 0, _validators = validators; _i < _validators.length; _i++) {
       var validator = _validators[_i];
@@ -39,4 +40,5 @@ var union = exports.union = function union() {
       type: value
     };
   };
+  return (0, _standardSchema.attachStandard)(unionValidator);
 };

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

@@ -7,6 +7,7 @@
  * The function is exported as `set_` because the top-level `Object` module
  * already exposes a `set` runtime helper.
  */
+import { type StandardSchemaV1 } from "../../Validate/standardSchema";
 import type { ValidateCoreReturnType, ValidateType } from "../../Validate/type";
 export type SetExtractValidatedType<V> = V extends (value: never) => {
     type: infer T;
@@ -20,4 +21,4 @@ export type SetExtractValidatedType<V> = V extends (value: never) => {
  * @param {string} [message] - Custom error message for type validation
  * @returns {Function} - Validator function for Set instances
  */
-export declare const set_: <IV extends (value: any) => ValidateCoreReturnType<unknown> = (value: unknown) => ValidateCoreReturnType<unknown>, T = SetExtractValidatedType<IV>>(itemValidator?: IV, message?: string) => (value: Set<T>) => ValidateCoreReturnType<Set<T>>;
+export declare const set_: <IV extends (value: any) => ValidateCoreReturnType<unknown> = (value: unknown) => ValidateCoreReturnType<unknown>, T = SetExtractValidatedType<IV>>(itemValidator?: IV, message?: string) => ((value: Set<T>) => ValidateCoreReturnType<Set<T>>) & StandardSchemaV1<Set<T>, Set<T>>;

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

@@ -4,10 +4,10 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.set_ = 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; } /**
  * Set validation core module
  * Provides validation for `Set` instances. The validator can optionally
  * delegate to a per-element validator, mirroring how `arrayOf()` validates
@@ -16,7 +16,6 @@ function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length)
  * The function is exported as `set_` because the top-level `Object` module
  * already exposes a `set` runtime helper.
  */
-
 /**
  * Creates a Set validator. When a per-element validator is supplied, every
  * element of the set must satisfy it; iteration short-circuits at the first
@@ -27,7 +26,7 @@ function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length)
  * @returns {Function} - Validator function for Set instances
  */
 var set_ = exports.set_ = function set_(itemValidator, message) {
-  return function (value) {
+  var setValidator = function setValidator(value) {
     if (!(value instanceof Set)) {
       return {
         validate: false,
@@ -62,4 +61,5 @@ var set_ = exports.set_ = function set_(itemValidator, message) {
       type: value
     };
   };
+  return (0, _standardSchema.attachStandard)(setValidator);
 };

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

@@ -0,0 +1,93 @@
+/**
+ * Standard Schema V1 integration
+ *
+ * Defines the public Standard Schema V1 surface (https://standardschema.dev)
+ * and exposes the `attachStandard()` helper used by every UMT validator
+ * factory to advertise itself as a Standard Schema V1 implementation. The
+ * `~standard` property added by `attachStandard()` lets external tools
+ * (Zod-, Valibot-, ArkType-style ecosystems) consume UMT validators without
+ * adapters.
+ *
+ * Biome's `noNamespace` lint rule forbids TypeScript namespaces, so the spec
+ * is mirrored with flat interface/type names that remain structurally
+ * compatible with the official `StandardSchemaV1` interface published by
+ * `@standard-schema/spec`.
+ */
+/** The Standard Schema V1 interface. */
+export interface StandardSchemaV1<Input = unknown, Output = Input> {
+    readonly "~standard": StandardSchemaV1Properties<Input, Output>;
+}
+/** The Standard Schema V1 properties interface. */
+export interface StandardSchemaV1Properties<Input = unknown, Output = Input> {
+    /** The version number of the standard. */
+    readonly version: 1;
+    /** The vendor name of the schema library. */
+    readonly vendor: string;
+    /** Validates unknown input values. */
+    readonly validate: (value: unknown) => StandardSchemaV1Result<Output> | Promise<StandardSchemaV1Result<Output>>;
+    /** Inferred types associated with the schema. */
+    readonly types?: StandardSchemaV1Types<Input, Output> | undefined;
+}
+/** The result type produced by `Props.validate`. */
+export type StandardSchemaV1Result<Output> = StandardSchemaV1SuccessResult<Output> | StandardSchemaV1FailureResult;
+/** The result interface when validation succeeds. */
+export interface StandardSchemaV1SuccessResult<Output> {
+    readonly value: Output;
+    readonly issues?: undefined;
+}
+/** The result interface when validation fails. */
+export interface StandardSchemaV1FailureResult {
+    readonly issues: readonly StandardSchemaV1Issue[];
+}
+/** The issue interface returned on failure. */
+export interface StandardSchemaV1Issue {
+    readonly message: string;
+    readonly path?: readonly (PropertyKey | StandardSchemaV1PathSegment)[] | undefined;
+}
+/** The path segment interface for nested issues. */
+export interface StandardSchemaV1PathSegment {
+    readonly key: PropertyKey;
+}
+/** The Standard Schema V1 types interface. */
+export interface StandardSchemaV1Types<Input = unknown, Output = Input> {
+    /** The input type of the schema. */
+    readonly input: Input;
+    /** The output type of the schema. */
+    readonly output: Output;
+}
+/** Infers the input type of a Standard Schema V1 implementation. */
+export type StandardSchemaV1InferInput<Schema extends StandardSchemaV1<any, any>> = NonNullable<Schema["~standard"]["types"]>["input"];
+/** Infers the output type of a Standard Schema V1 implementation. */
+export type StandardSchemaV1InferOutput<Schema extends StandardSchemaV1<any, any>> = NonNullable<Schema["~standard"]["types"]>["output"];
+/**
+ * Vendor identifier used by all UMT validators when advertising Standard
+ * Schema V1 compatibility. External tools may key off this value to attach
+ * UMT-specific behavior.
+ */
+export declare const STANDARD_SCHEMA_VENDOR = "umt";
+/** Minimal shape of UMT validator results consumed by `attachStandard`. */
+export interface UmtValidatorResult {
+    validate: boolean;
+    message: string;
+    type: unknown;
+}
+/**
+ * Attaches a Standard Schema V1 `~standard` property to a UMT validator
+ * function in place. The validator's existing call signature, attached
+ * helpers (such as `shape` on `object()` or `implement` on `function_()`),
+ * and return type are preserved untouched; only the `~standard` property is
+ * added.
+ *
+ * Validation is delegated to the wrapped validator. On success the input
+ * value is returned through the Standard Schema `value` field; on failure a
+ * single issue carrying the validator's message is emitted. UMT validators
+ * never transform their input, so `Input` and `Output` default to the same
+ * type.
+ *
+ * @template Input - The input type advertised through `~standard.types`
+ * @template Output - The output type advertised through `~standard.types`
+ * @template F - The validator function being augmented
+ * @param {F} validator - The validator function to augment
+ * @returns {F & StandardSchemaV1<Input, Output>} The same function with `~standard` attached
+ */
+export declare const attachStandard: <Input, Output = Input, F extends (...arguments_: any[]) => UmtValidatorResult = (...arguments_: any[]) => UmtValidatorResult>(validator: F) => F & StandardSchemaV1<Input, Output>;