umt 2.20.0 → 3.0.0

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

@@ -1,14 +1,17 @@
-import type { ValidateCoreReturnType } from "../../Validate/type";
+import type { ValidateCoreReturnType, ValidateType } from "../../Validate/type";
+type ExtractValidatedType<V> = V extends (value: never) => {
+    type: infer T;
+} ? ValidateType<T> : never;
 /**
  * Creates an array validator that validates every element with a single validator
- * @template T - Element type validated by the wrapped validator
- * @template R - The return type of the wrapped validator (preserved so the inner type tag flows through)
- * @param {Function} validator - Validator applied to each element (e.g. an object validator)
+ * @template V - The validator function applied to each element (its return `type` field carries the element type)
+ * @param {V} validator - Validator applied to each element (e.g. an object validator)
  * @param {string} [message] - Custom error message for array type validation
  * @returns {Function} - Validator function for arrays whose elements satisfy the given validator
  */
-export declare const arrayOf: <T, R extends {
+export declare const arrayOf: <V extends (value: never) => {
     type: unknown;
     message: string;
     validate: boolean;
-}>(validator: (value: T) => R, message?: string) => (values: T[]) => ValidateCoreReturnType<T[]>;
+}>(validator: V, message?: string) => (values: ExtractValidatedType<V>[]) => ValidateCoreReturnType<ExtractValidatedType<V>[]>;
+export {};

package/module/Validate/array/arrayOf.js

@@ -1,9 +1,8 @@
 import { isArray } from "../../Validate/isArray";
 /**
  * Creates an array validator that validates every element with a single validator
- * @template T - Element type validated by the wrapped validator
- * @template R - The return type of the wrapped validator (preserved so the inner type tag flows through)
- * @param {Function} validator - Validator applied to each element (e.g. an object validator)
+ * @template V - The validator function applied to each element (its return `type` field carries the element type)
+ * @param {V} validator - Validator applied to each element (e.g. an object validator)
  * @param {string} [message] - Custom error message for array type validation
  * @returns {Function} - Validator function for arrays whose elements satisfy the given validator
  */

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

@@ -1 +1 @@
-{"version":3,"file":"arrayOf.js","sourceRoot":"","sources":["../../../src/Validate/array/arrayOf.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAG7C;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG,CAIrB,SAA0B,EAC1B,OAAgB,EAChB,EAAE;IACF,OAAO,CAAC,MAAW,EAA+B,EAAE;QAClD,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC;YACrB,OAAO;gBACL,QAAQ,EAAE,KAAK;gBACf,OAAO,EAAE,OAAO,IAAI,EAAE;gBACtB,IAAI,EAAE,MAAM;aACb,CAAC;QACJ,CAAC;QACD,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;YAC3B,MAAM,MAAM,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC;YAChC,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC;gBACrB,OAAO;oBACL,QAAQ,EAAE,KAAK;oBACf,OAAO,EAAE,MAAM,CAAC,OAAO;oBACvB,IAAI,EAAE,MAAM;iBACb,CAAC;YACJ,CAAC;QACH,CAAC;QACD,OAAO;YACL,QAAQ,EAAE,IAAI;YACd,OAAO,EAAE,EAAE;YACX,IAAI,EAAE,MAAM;SACb,CAAC;IACJ,CAAC,CAAC;AACJ,CAAC,CAAC"}
+{"version":3,"file":"arrayOf.js","sourceRoot":"","sources":["../../../src/Validate/array/arrayOf.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAY7C;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG,CAOrB,SAAY,EACZ,OAAgB,EAChB,EAAE;IAEF,OAAO,CAAC,MAAiB,EAAqC,EAAE;QAC9D,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC;YACrB,OAAO;gBACL,QAAQ,EAAE,KAAK;gBACf,OAAO,EAAE,OAAO,IAAI,EAAE;gBACtB,IAAI,EAAE,MAAM;aACb,CAAC;QACJ,CAAC;QACD,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;YAC3B,MAAM,MAAM,GACV,SAID,CAAC,KAAK,CAAC,CAAC;YACT,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC;gBACrB,OAAO;oBACL,QAAQ,EAAE,KAAK;oBACf,OAAO,EAAE,MAAM,CAAC,OAAO;oBACvB,IAAI,EAAE,MAAM;iBACb,CAAC;YACJ,CAAC;QACH,CAAC;QACD,OAAO;YACL,QAAQ,EAAE,IAAI;YACd,OAAO,EAAE,EAAE;YACX,IAAI,EAAE,MAAM;SACb,CAAC;IACJ,CAAC,CAAC;AACJ,CAAC,CAAC"}

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

@@ -1,2 +1 @@
 export * from "./arrayOf";
-export * from "./core";

package/module/Validate/array/index.js

@@ -1,3 +1,2 @@
 export * from "./arrayOf";
-export * from "./core";
 //# sourceMappingURL=index.js.map

package/module/Validate/array/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/Validate/array/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,QAAQ,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/Validate/array/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC"}

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

@@ -1,12 +1,15 @@
-import type { UnionToIntersection } from "../../types/logic";
 import type { ValidateCoreReturnType, ValidateType } from "../../Validate/type";
 type ExtractValidatedType<V> = V extends (value: never) => {
     type: infer T;
 } ? ValidateType<T> : never;
+type IntersectValidatedTypes<Vs> = Vs extends readonly [
+    infer Head,
+    ...infer Tail
+] ? ExtractValidatedType<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: UnionToIntersection<ExtractValidatedType<Vs[number]>>) => ValidateCoreReturnType<UnionToIntersection<ExtractValidatedType<Vs[number]>>>;
+export declare const intersection: <Vs extends ((value: never) => ValidateCoreReturnType<unknown>)[]>(...validators: [...Vs]) => (value: IntersectValidatedTypes<Vs>) => ValidateCoreReturnType<IntersectValidatedTypes<Vs>>;
 export {};

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

@@ -1 +1 @@
-{"version":3,"file":"intersection.js","sourceRoot":"","sources":["../../../src/Validate/object/intersection.ts"],"names":[],"mappings":"AAgBA;;;;GAIG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,CAG1B,GAAG,UAAmB,EACtB,EAAE;IACF,OAAO,CACL,KAA4D,EAG5D,EAAE;QACF,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE,CAAC;YACnC,MAAM,MAAM,GACV,SAKD,CAAC,KAAK,CAAC,CAAC;YACT,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC;gBACrB,OAAO;oBACL,QAAQ,EAAE,KAAK;oBACf,OAAO,EAAE,MAAM,CAAC,OAAO;oBACvB,IAAI,EAAE,KAEL;iBACF,CAAC;YACJ,CAAC;QACH,CAAC;QACD,OAAO;YACL,QAAQ,EAAE,IAAI;YACd,OAAO,EAAE,EAAE;YACX,IAAI,EAAE,KAEL;SACF,CAAC;IACJ,CAAC,CAAC;AACJ,CAAC,CAAC"}
+{"version":3,"file":"intersection.js","sourceRoot":"","sources":["../../../src/Validate/object/intersection.ts"],"names":[],"mappings":"AA2BA;;;;GAIG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,CAG1B,GAAG,UAAmB,EACtB,EAAE;IACF,OAAO,CACL,KAAkC,EACmB,EAAE;QACvD,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE,CAAC;YACnC,MAAM,MAAM,GACV,SAGD,CAAC,KAAK,CAAC,CAAC;YACT,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC;gBACrB,OAAO;oBACL,QAAQ,EAAE,KAAK;oBACf,OAAO,EAAE,MAAM,CAAC,OAAO;oBACvB,IAAI,EAAE,KAAsD;iBAC7D,CAAC;YACJ,CAAC;QACH,CAAC;QACD,OAAO;YACL,QAAQ,EAAE,IAAI;YACd,OAAO,EAAE,EAAE;YACX,IAAI,EAAE,KAAsD;SAC7D,CAAC;IACJ,CAAC,CAAC;AACJ,CAAC,CAAC"}

package/module/Validate/string/oneOf.d.ts

@@ -5,20 +5,23 @@
  * such as `'standard' | 'squat' | 'decanter' | 'round' | 'tall' | 'flask'`.
  *
  * The validator's return type carries the literal union through its `type`
- * field directly (instead of going through `Types<T>` which would collapse
- * to `"string"`), so consumers like `object()`, `union()`, and `intersection()`
- * can preserve the literal union in their inferred types.
+ * field as a `LiteralBrand<T>` so that consumers like `object()`, `union()`,
+ * and `intersection()` can preserve the literal union in their inferred types.
+ * The brand also prevents collisions with reserved type tags such as
+ * `"string"`, `"number"`, or `"boolean"` when an allowed value happens to
+ * match one of those tag strings.
  */
+import type { LiteralBrand } from "../../Validate/type";
 /**
  * Return type produced by a `oneOf` validator. Structurally compatible with
- * `ValidateCoreReturnType<unknown>`, but exposes the literal union directly
- * via the `type` field so the inferred type can flow through `object()`,
- * `union()`, and `intersection()` without being collapsed to `string`.
+ * `ValidateCoreReturnType<unknown>`, but exposes the literal union via a
+ * `LiteralBrand` so the inferred type can flow through `object()`, `union()`,
+ * and `intersection()` without being collapsed by `ValidateType`.
  */
 export interface OneOfReturnType<T extends string> {
     validate: boolean;
     message: string;
-    type: T;
+    type: LiteralBrand<T>;
 }
 /**
  * Creates a top-level validator that checks if a string value is one of the

package/module/Validate/string/oneOf.js

@@ -5,9 +5,11 @@
  * such as `'standard' | 'squat' | 'decanter' | 'round' | 'tall' | 'flask'`.
  *
  * The validator's return type carries the literal union through its `type`
- * field directly (instead of going through `Types<T>` which would collapse
- * to `"string"`), so consumers like `object()`, `union()`, and `intersection()`
- * can preserve the literal union in their inferred types.
+ * field as a `LiteralBrand<T>` so that consumers like `object()`, `union()`,
+ * and `intersection()` can preserve the literal union in their inferred types.
+ * The brand also prevents collisions with reserved type tags such as
+ * `"string"`, `"number"`, or `"boolean"` when an allowed value happens to
+ * match one of those tag strings.
  */
 /**
  * Creates a top-level validator that checks if a string value is one of the

package/module/Validate/string/oneOf.js.map

@@ -1 +1 @@
-{"version":3,"file":"oneOf.js","sourceRoot":"","sources":["../../../src/Validate/string/oneOf.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAcH;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,KAAK,GAAG,CACnB,MAAS,EACT,OAAgB,EAChB,EAAE;IACF,MAAM,OAAO,GAAG,IAAI,GAAG,CAAS,MAAM,CAAC,CAAC;IACxC,OAAO,CAAC,KAAa,EAA8B,EAAE;QACnD,MAAM,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QACnC,OAAO;YACL,QAAQ,EAAE,OAAO;YACjB,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,OAAO,IAAI,EAAE,CAAC;YACvC,IAAI,EAAE,KAAK;SACZ,CAAC;IACJ,CAAC,CAAC;AACJ,CAAC,CAAC"}
+{"version":3,"file":"oneOf.js","sourceRoot":"","sources":["../../../src/Validate/string/oneOf.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAgBH;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,KAAK,GAAG,CACnB,MAAS,EACT,OAAgB,EAChB,EAAE;IACF,MAAM,OAAO,GAAG,IAAI,GAAG,CAAS,MAAM,CAAC,CAAC;IACxC,OAAO,CAAC,KAAa,EAA8B,EAAE;QACnD,MAAM,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QACnC,OAAO;YACL,QAAQ,EAAE,OAAO;YACjB,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,OAAO,IAAI,EAAE,CAAC;YACvC,IAAI,EAAE,KAAgC;SACvC,CAAC;IACJ,CAAC,CAAC;AACJ,CAAC,CAAC"}

package/module/Validate/type.d.ts

@@ -30,16 +30,28 @@ export interface ValidateReturnType<T> {
  * @template T - The type of value to validate
  */
 export type ValidateFunctionType<T> = (value: T) => boolean;
+declare const LITERAL_BRAND: unique symbol;
+/**
+ * Branded literal type used by validators (such as `oneOf`) that need to keep
+ * a string literal verbatim through `ValidateType`. The brand prevents the
+ * literal from colliding with reserved type tags like `"string"`, `"number"`,
+ * or `"boolean"` when the same string also happens to name a primitive type.
+ * @template T - The literal value preserved by the brand
+ */
+export type LiteralBrand<T extends string> = T & {
+    readonly [LITERAL_BRAND]: T;
+};
 export type _ValidateType<T> = T extends "string" ? string : T extends "number" ? number : T extends "boolean" ? boolean : T;
 export type _ValidateType2<T> = T extends "undefined" ? undefined : T extends "null" ? null : T;
 export type _ValidateType3<T> = T extends "bigint" ? bigint : T extends "any" ? any : T extends "unknown" ? unknown : T extends "never" ? never : T;
 /**
  * Maps string literal type names back to their TypeScript types
  * @template T - The string literal type name ("string", "number", "boolean", "bigint", "undefined", "null", "any", "unknown", "never")
- * @returns The corresponding TypeScript type or the original type T when no tag matches
+ * @returns The corresponding TypeScript type, the unwrapped literal when `T` is a `LiteralBrand`, or the original type `T` when no tag matches
  */
-export type ValidateType<T> = T extends "string" | "number" | "boolean" ? _ValidateType<T> : T extends "undefined" | "null" ? _ValidateType2<T> : T extends "bigint" | "any" | "unknown" | "never" ? _ValidateType3<T> : T;
+export type ValidateType<T> = T extends LiteralBrand<infer L> ? L : T extends "string" | "number" | "boolean" ? _ValidateType<T> : T extends "undefined" | "null" ? _ValidateType2<T> : T extends "bigint" | "any" | "unknown" | "never" ? _ValidateType3<T> : T;
 export type SchemaToInterface<T extends (value: any) => ValidateCoreReturnType<any>> = ValidateType<ReturnType<T>["type"]>;
 export type OptionalKeys<T> = {
     [K in keyof T]: undefined extends T[K] ? K : never;
 }[keyof T];
+export {};

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

@@ -1,14 +1,17 @@
-import type { ValidateCoreReturnType } from "../../Validate/type";
+import type { ValidateCoreReturnType, ValidateType } from "../../Validate/type";
+type ExtractValidatedType<V> = V extends (value: never) => {
+    type: infer T;
+} ? ValidateType<T> : never;
 /**
  * Creates an array validator that validates every element with a single validator
- * @template T - Element type validated by the wrapped validator
- * @template R - The return type of the wrapped validator (preserved so the inner type tag flows through)
- * @param {Function} validator - Validator applied to each element (e.g. an object validator)
+ * @template V - The validator function applied to each element (its return `type` field carries the element type)
+ * @param {V} validator - Validator applied to each element (e.g. an object validator)
  * @param {string} [message] - Custom error message for array type validation
  * @returns {Function} - Validator function for arrays whose elements satisfy the given validator
  */
-export declare const arrayOf: <T, R extends {
+export declare const arrayOf: <V extends (value: never) => {
     type: unknown;
     message: string;
     validate: boolean;
-}>(validator: (value: T) => R, message?: string) => (values: T[]) => ValidateCoreReturnType<T[]>;
+}>(validator: V, message?: string) => (values: ExtractValidatedType<V>[]) => ValidateCoreReturnType<ExtractValidatedType<V>[]>;
+export {};

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

@@ -8,11 +8,16 @@ var _isArray = require("../../Validate/isArray");
 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; }
+// 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
+// literal union via the `type` field (such as `oneOf`) flow through arrayOf
+// without being collapsed to `string`.
+
 /**
  * Creates an array validator that validates every element with a single validator
- * @template T - Element type validated by the wrapped validator
- * @template R - The return type of the wrapped validator (preserved so the inner type tag flows through)
- * @param {Function} validator - Validator applied to each element (e.g. an object validator)
+ * @template V - The validator function applied to each element (its return `type` field carries the element type)
+ * @param {V} validator - Validator applied to each element (e.g. an object validator)
  * @param {string} [message] - Custom error message for array type validation
  * @returns {Function} - Validator function for arrays whose elements satisfy the given validator
  */
@@ -29,8 +34,8 @@ var arrayOf = exports.arrayOf = function arrayOf(validator, message) {
       _step;
     try {
       for (_iterator.s(); !(_step = _iterator.n()).done;) {
-        var value = _step.value;
-        var result = validator(value);
+        var _value = _step.value;
+        var result = validator(_value);
         if (!result.validate) {
           return {
             validate: false,

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

@@ -1,2 +1 @@
 export * from "./arrayOf";
-export * from "./core";

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

@@ -13,15 +13,4 @@ Object.keys(_arrayOf).forEach(function (key) {
       return _arrayOf[key];
     }
   });
-});
-var _core = require("./core");
-Object.keys(_core).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _core[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function get() {
-      return _core[key];
-    }
-  });
 });

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

@@ -1,12 +1,15 @@
-import type { UnionToIntersection } from "../../types/logic";
 import type { ValidateCoreReturnType, ValidateType } from "../../Validate/type";
 type ExtractValidatedType<V> = V extends (value: never) => {
     type: infer T;
 } ? ValidateType<T> : never;
+type IntersectValidatedTypes<Vs> = Vs extends readonly [
+    infer Head,
+    ...infer Tail
+] ? ExtractValidatedType<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: UnionToIntersection<ExtractValidatedType<Vs[number]>>) => ValidateCoreReturnType<UnionToIntersection<ExtractValidatedType<Vs[number]>>>;
+export declare const intersection: <Vs extends ((value: never) => ValidateCoreReturnType<unknown>)[]>(...validators: [...Vs]) => (value: IntersectValidatedTypes<Vs>) => ValidateCoreReturnType<IntersectValidatedTypes<Vs>>;
 export {};

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

@@ -10,6 +10,12 @@ exports.intersection = void 0;
 // literal union via the `type` field (such as `oneOf`) flow through
 // intersection without being collapsed by `Types<T>`.
 
+// Walk the validator tuple and `&`-combine each element's extracted type.
+// Reducing element-by-element preserves any union exposed by an individual
+// validator (e.g. `union(A, B)`), unlike `UnionToIntersection` over
+// `Vs[number]` which would distribute over the inner union and collapse
+// `(A | B) & C` into `A & B & C`.
+
 /**
  * Creates an intersection validator that passes only if all given validators pass
  * @param validators - Validator functions to compose as an intersection (logical AND)

package/module/es5/Validate/string/oneOf.d.ts

@@ -5,20 +5,23 @@
  * such as `'standard' | 'squat' | 'decanter' | 'round' | 'tall' | 'flask'`.
  *
  * The validator's return type carries the literal union through its `type`
- * field directly (instead of going through `Types<T>` which would collapse
- * to `"string"`), so consumers like `object()`, `union()`, and `intersection()`
- * can preserve the literal union in their inferred types.
+ * field as a `LiteralBrand<T>` so that consumers like `object()`, `union()`,
+ * and `intersection()` can preserve the literal union in their inferred types.
+ * The brand also prevents collisions with reserved type tags such as
+ * `"string"`, `"number"`, or `"boolean"` when an allowed value happens to
+ * match one of those tag strings.
  */
+import type { LiteralBrand } from "../../Validate/type";
 /**
  * Return type produced by a `oneOf` validator. Structurally compatible with
- * `ValidateCoreReturnType<unknown>`, but exposes the literal union directly
- * via the `type` field so the inferred type can flow through `object()`,
- * `union()`, and `intersection()` without being collapsed to `string`.
+ * `ValidateCoreReturnType<unknown>`, but exposes the literal union via a
+ * `LiteralBrand` so the inferred type can flow through `object()`, `union()`,
+ * and `intersection()` without being collapsed by `ValidateType`.
  */
 export interface OneOfReturnType<T extends string> {
     validate: boolean;
     message: string;
-    type: T;
+    type: LiteralBrand<T>;
 }
 /**
  * Creates a top-level validator that checks if a string value is one of the

package/module/es5/Validate/string/oneOf.js

@@ -11,16 +11,18 @@ exports.oneOf = void 0;
  * such as `'standard' | 'squat' | 'decanter' | 'round' | 'tall' | 'flask'`.
  *
  * The validator's return type carries the literal union through its `type`
- * field directly (instead of going through `Types<T>` which would collapse
- * to `"string"`), so consumers like `object()`, `union()`, and `intersection()`
- * can preserve the literal union in their inferred types.
+ * field as a `LiteralBrand<T>` so that consumers like `object()`, `union()`,
+ * and `intersection()` can preserve the literal union in their inferred types.
+ * The brand also prevents collisions with reserved type tags such as
+ * `"string"`, `"number"`, or `"boolean"` when an allowed value happens to
+ * match one of those tag strings.
  */
 
 /**
  * Return type produced by a `oneOf` validator. Structurally compatible with
- * `ValidateCoreReturnType<unknown>`, but exposes the literal union directly
- * via the `type` field so the inferred type can flow through `object()`,
- * `union()`, and `intersection()` without being collapsed to `string`.
+ * `ValidateCoreReturnType<unknown>`, but exposes the literal union via a
+ * `LiteralBrand` so the inferred type can flow through `object()`, `union()`,
+ * and `intersection()` without being collapsed by `ValidateType`.
  */
 
 /**

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

@@ -30,16 +30,28 @@ export interface ValidateReturnType<T> {
  * @template T - The type of value to validate
  */
 export type ValidateFunctionType<T> = (value: T) => boolean;
+declare const LITERAL_BRAND: unique symbol;
+/**
+ * Branded literal type used by validators (such as `oneOf`) that need to keep
+ * a string literal verbatim through `ValidateType`. The brand prevents the
+ * literal from colliding with reserved type tags like `"string"`, `"number"`,
+ * or `"boolean"` when the same string also happens to name a primitive type.
+ * @template T - The literal value preserved by the brand
+ */
+export type LiteralBrand<T extends string> = T & {
+    readonly [LITERAL_BRAND]: T;
+};
 export type _ValidateType<T> = T extends "string" ? string : T extends "number" ? number : T extends "boolean" ? boolean : T;
 export type _ValidateType2<T> = T extends "undefined" ? undefined : T extends "null" ? null : T;
 export type _ValidateType3<T> = T extends "bigint" ? bigint : T extends "any" ? any : T extends "unknown" ? unknown : T extends "never" ? never : T;
 /**
  * Maps string literal type names back to their TypeScript types
  * @template T - The string literal type name ("string", "number", "boolean", "bigint", "undefined", "null", "any", "unknown", "never")
- * @returns The corresponding TypeScript type or the original type T when no tag matches
+ * @returns The corresponding TypeScript type, the unwrapped literal when `T` is a `LiteralBrand`, or the original type `T` when no tag matches
  */
-export type ValidateType<T> = T extends "string" | "number" | "boolean" ? _ValidateType<T> : T extends "undefined" | "null" ? _ValidateType2<T> : T extends "bigint" | "any" | "unknown" | "never" ? _ValidateType3<T> : T;
+export type ValidateType<T> = T extends LiteralBrand<infer L> ? L : T extends "string" | "number" | "boolean" ? _ValidateType<T> : T extends "undefined" | "null" ? _ValidateType2<T> : T extends "bigint" | "any" | "unknown" | "never" ? _ValidateType3<T> : T;
 export type SchemaToInterface<T extends (value: any) => ValidateCoreReturnType<any>> = ValidateType<ReturnType<T>["type"]>;
 export type OptionalKeys<T> = {
     [K in keyof T]: undefined extends T[K] ? K : never;
 }[keyof T];
+export {};

package/package.json

@@ -226,5 +226,5 @@
   },
   "type": "module",
   "types": "module/index.d.ts",
-  "version": "2.20.0"
+  "version": "3.0.0"
 }

package/module/Validate/array/core.d.ts

@@ -1,14 +0,0 @@
-/**
- * Array validation core module
- * Provides functionality to validate arrays with type-specific validation rules
- */
-import type { Types, ValidateCoreReturnType, ValidateType } from "../../Validate/type";
-/**
- * Creates an array validator with type-specific validation rules
- * @template A - Type of array elements (string | number | boolean)
- * @template O - Object containing validation functions for each type
- * @param {O} option - Validation functions for each type
- * @param {string} [message] - Custom error message for array type validation
- * @returns {Function} - Validator function for arrays
- */
-export declare const array: <A extends string | number | boolean, O extends { [P in Types<A>]: (value: ValidateType<P>) => ValidateCoreReturnType<ValidateType<P>>; } = { [P in Types<A>]: (value: ValidateType<P>) => ValidateCoreReturnType<ValidateType<P>>; }>(option?: O, message?: string) => (values: A[]) => ValidateCoreReturnType<A[]>;

package/module/Validate/array/core.js

@@ -1,43 +0,0 @@
-/**
- * Array validation core module
- * Provides functionality to validate arrays with type-specific validation rules
- */
-import { isArray } from "../../Validate/isArray";
-import { isNotEmpty } from "../../Validate/isNotEmpty";
-/**
- * Creates an array validator with type-specific validation rules
- * @template A - Type of array elements (string | number | boolean)
- * @template O - Object containing validation functions for each type
- * @param {O} option - Validation functions for each type
- * @param {string} [message] - Custom error message for array type validation
- * @returns {Function} - Validator function for arrays
- */
-export const array = (option = {}, message) => {
-    return (values) => {
-        if (!isArray(values)) {
-            return {
-                validate: false,
-                message: message ?? "",
-                type: values,
-            };
-        }
-        if (isNotEmpty(option)) {
-            for (const value of values) {
-                const validator = option[typeof value];
-                if (!validator?.(value).validate) {
-                    return {
-                        validate: false,
-                        message: validator?.(value).message || "",
-                        type: values,
-                    };
-                }
-            }
-        }
-        return {
-            validate: true,
-            message: "",
-            type: values,
-        };
-    };
-};
-//# sourceMappingURL=core.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"core.js","sourceRoot":"","sources":["../../../src/Validate/array/core.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAC7C,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAOnD;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,KAAK,GAAG,CAYnB,SAAY,EAAO,EACnB,OAAgB,EAChB,EAAE;IACF,OAAO,CAAC,MAAW,EAA+B,EAAE;QAClD,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC;YACrB,OAAO;gBACL,QAAQ,EAAE,KAAK;gBACf,OAAO,EAAE,OAAO,IAAI,EAAE;gBACtB,IAAI,EAAE,MAAM;aACb,CAAC;QACJ,CAAC;QACD,IAAI,UAAU,CAAC,MAAM,CAAC,EAAE,CAAC;YACvB,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;gBAC3B,MAAM,SAAS,GAAG,MAAM,CAAC,OAAO,KAAiB,CAAC,CAAC;gBACnD,IAAI,CAAC,SAAS,EAAE,CAAC,KAAc,CAAC,CAAC,QAAQ,EAAE,CAAC;oBAC1C,OAAO;wBACL,QAAQ,EAAE,KAAK;wBACf,OAAO,EAAE,SAAS,EAAE,CAAC,KAAc,CAAC,CAAC,OAAO,IAAI,EAAE;wBAClD,IAAI,EAAE,MAAM;qBACb,CAAC;gBACJ,CAAC;YACH,CAAC;QACH,CAAC;QACD,OAAO;YACL,QAAQ,EAAE,IAAI;YACd,OAAO,EAAE,EAAE;YACX,IAAI,EAAE,MAAM;SACb,CAAC;IACJ,CAAC,CAAC;AACJ,CAAC,CAAC"}

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

@@ -1,14 +0,0 @@
-/**
- * Array validation core module
- * Provides functionality to validate arrays with type-specific validation rules
- */
-import type { Types, ValidateCoreReturnType, ValidateType } from "../../Validate/type";
-/**
- * Creates an array validator with type-specific validation rules
- * @template A - Type of array elements (string | number | boolean)
- * @template O - Object containing validation functions for each type
- * @param {O} option - Validation functions for each type
- * @param {string} [message] - Custom error message for array type validation
- * @returns {Function} - Validator function for arrays
- */
-export declare const array: <A extends string | number | boolean, O extends { [P in Types<A>]: (value: ValidateType<P>) => ValidateCoreReturnType<ValidateType<P>>; } = { [P in Types<A>]: (value: ValidateType<P>) => ValidateCoreReturnType<ValidateType<P>>; }>(option?: O, message?: string) => (values: A[]) => ValidateCoreReturnType<A[]>;

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

@@ -1,62 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.array = void 0;
-var _isArray = require("../../Validate/isArray");
-var _isNotEmpty = require("../../Validate/isNotEmpty");
-function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
-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; } /**
- * Array validation core module
- * Provides functionality to validate arrays with type-specific validation rules
- */
-/**
- * Creates an array validator with type-specific validation rules
- * @template A - Type of array elements (string | number | boolean)
- * @template O - Object containing validation functions for each type
- * @param {O} option - Validation functions for each type
- * @param {string} [message] - Custom error message for array type validation
- * @returns {Function} - Validator function for arrays
- */
-var array = exports.array = function array() {
-  var option = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-  var message = arguments.length > 1 ? arguments[1] : undefined;
-  return function (values) {
-    if (!(0, _isArray.isArray)(values)) {
-      return {
-        validate: false,
-        message: message !== null && message !== void 0 ? message : "",
-        type: values
-      };
-    }
-    if ((0, _isNotEmpty.isNotEmpty)(option)) {
-      var _iterator = _createForOfIteratorHelper(values),
-        _step;
-      try {
-        for (_iterator.s(); !(_step = _iterator.n()).done;) {
-          var _value = _step.value;
-          var validator = option[_typeof(_value)];
-          if (!(validator !== null && validator !== void 0 && validator(_value).validate)) {
-            return {
-              validate: false,
-              message: (validator === null || validator === void 0 ? void 0 : validator(_value).message) || "",
-              type: values
-            };
-          }
-        }
-      } catch (err) {
-        _iterator.e(err);
-      } finally {
-        _iterator.f();
-      }
-    }
-    return {
-      validate: true,
-      message: "",
-      type: values
-    };
-  };
-};