umt 2.19.0 → 3.0.0

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

@@ -0,0 +1,45 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.pick_ = void 0;
+var _core = require("./core");
+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; } /**
+ * Object validation - pick
+ * Returns a new object validator that only checks the specified keys of the
+ * source validator. Mirrors `Pick<T, K>` at the type level so consumers like
+ * `union()`, `intersection()`, and `SchemaToInterface` see the narrowed shape.
+ *
+ * The function is exported as `pick_` because the top-level `Object` module
+ * already exposes a `pick` runtime helper.
+ */
+/**
+ * Picks the given keys from an existing object validator and returns a new
+ * object validator covering only those keys.
+ * @template T - Original object shape
+ * @template K - Tuple of keys to pick from the original shape
+ * @param {ObjectValidator<T>} validator - Source object validator
+ * @param {K} keys - Keys to retain on the new validator
+ * @param {string} [message] - Custom error message for the picked validator
+ * @returns {ObjectValidator<Pick<T, K[number]>>} - New validator scoped to picked keys
+ */
+var pick_ = exports.pick_ = function pick_(validator, keys, message) {
+  var sourceShape = validator.shape;
+  var nextShape = {};
+  var _iterator = _createForOfIteratorHelper(keys),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var key = _step.value;
+      nextShape[key] = sourceShape[key];
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return (0, _core.object)(nextShape, message);
+};

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

@@ -0,0 +1,22 @@
+/**
+ * Object validation - required
+ * Returns a new object validator where every key is unwrapped from any
+ * `optional()` layer, mirroring `Required<T>` at the type level so consumers
+ * see all properties as required again.
+ */
+import { type ObjectShape, type ObjectValidator } from "./core";
+import type { OptionalValidator } from "./optional";
+type UnwrapOptional<V> = V extends OptionalValidator<infer Inner, infer R> ? (value: Inner) => R : V;
+type RequiredShape<T extends ObjectShape> = {
+    [K in keyof T]: UnwrapOptional<T[K]> extends ObjectShape[string] ? UnwrapOptional<T[K]> : T[K];
+};
+/**
+ * Strips `optional()` wrappers from every property validator of `validator`.
+ * Validators that are not wrapped in `optional()` are kept as-is.
+ * @template T - Original object shape
+ * @param {ObjectValidator<T>} validator - Source object validator
+ * @param {string} [message] - Custom error message for the new validator
+ * @returns {ObjectValidator<RequiredShape<T>>} - New validator where every optional layer is removed
+ */
+export declare const required: <T extends ObjectShape>(validator: ObjectValidator<T>, message?: string) => ObjectValidator<RequiredShape<T>>;
+export {};

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

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.required = void 0;
+var _core = require("./core");
+/**
+ * Object validation - required
+ * Returns a new object validator where every key is unwrapped from any
+ * `optional()` layer, mirroring `Required<T>` at the type level so consumers
+ * see all properties as required again.
+ */
+
+/**
+ * Strips `optional()` wrappers from every property validator of `validator`.
+ * Validators that are not wrapped in `optional()` are kept as-is.
+ * @template T - Original object shape
+ * @param {ObjectValidator<T>} validator - Source object validator
+ * @param {string} [message] - Custom error message for the new validator
+ * @returns {ObjectValidator<RequiredShape<T>>} - New validator where every optional layer is removed
+ */
+var required = exports.required = function required(validator, message) {
+  var sourceShape = validator.shape;
+  var nextShape = {};
+  for (var _i = 0, _Object$keys = Object.keys(sourceShape); _i < _Object$keys.length; _i++) {
+    var key = _Object$keys[_i];
+    var current = sourceShape[key];
+    var optionalLike = current;
+    nextShape[key] = optionalLike.isOptional === true && typeof optionalLike.inner === "function" ? optionalLike.inner : current;
+  }
+  return (0, _core.object)(nextShape, message);
+};

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

@@ -0,0 +1,24 @@
+/**
+ * Set validation core module
+ * Provides validation for `Set` instances. The validator can optionally
+ * delegate to a per-element validator, mirroring how `arrayOf()` validates
+ * each element of an array.
+ *
+ * The function is exported as `set_` because the top-level `Object` module
+ * already exposes a `set` runtime helper.
+ */
+import type { ValidateCoreReturnType, ValidateType } from "../../Validate/type";
+type ExtractValidatedType<V> = V extends (value: never) => {
+    type: infer T;
+} ? ValidateType<T> : never;
+/**
+ * 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
+ * failure and surfaces the failing message.
+ * @template IV - Validator for set elements
+ * @param {IV} [itemValidator] - Validator applied to every element
+ * @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 = ExtractValidatedType<IV>>(itemValidator?: IV, message?: string) => (value: Set<T>) => ValidateCoreReturnType<Set<T>>;
+export {};

package/module/es5/Validate/{array → set}/core.js

@@ -3,47 +3,50 @@
 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); }
+exports.set_ = void 0;
 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
+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
+ * each element of an array.
+ *
+ * The function is exported as `set_` because the top-level `Object` module
+ * already exposes a `set` runtime helper.
  */
+
 /**
- * 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
+ * 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
+ * failure and surfaces the failing message.
+ * @template IV - Validator for set elements
+ * @param {IV} [itemValidator] - Validator applied to every element
+ * @param {string} [message] - Custom error message for type validation
+ * @returns {Function} - Validator function for Set instances
  */
-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)) {
+var set_ = exports.set_ = function set_(itemValidator, message) {
+  return function (value) {
+    if (!(value instanceof Set)) {
       return {
         validate: false,
         message: message !== null && message !== void 0 ? message : "",
-        type: values
+        type: value
       };
     }
-    if ((0, _isNotEmpty.isNotEmpty)(option)) {
-      var _iterator = _createForOfIteratorHelper(values),
+    if (itemValidator) {
+      var _iterator = _createForOfIteratorHelper(value),
         _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)) {
+          var item = _step.value;
+          var result = itemValidator(item);
+          if (!result.validate) {
             return {
               validate: false,
-              message: (validator === null || validator === void 0 ? void 0 : validator(_value).message) || "",
-              type: values
+              message: result.message,
+              type: value
             };
           }
         }
@@ -56,7 +59,7 @@ var array = exports.array = function array() {
     return {
       validate: true,
       message: "",
-      type: values
+      type: value
     };
   };
 };

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

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

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

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+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/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/templateLiteral/core.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Template literal validation core module
+ * Provides a validator that checks whether a string matches a template
+ * literal pattern composed of string fragments and primitive validators
+ * (string / number / boolean / bigint). The runtime check is performed by
+ * an auto-generated regular expression assembled from the parts, while the
+ * inferred type is the corresponding TypeScript template literal type.
+ */
+import type { ValidateType } from "../../Validate/type";
+type AnyValidator = (value?: any) => {
+    type: unknown;
+};
+/**
+ * Allowed parts of a template literal definition. Each element is either a
+ * string literal that must appear verbatim, or a primitive validator whose
+ * accepted shape is converted to a regex fragment at construction time.
+ */
+export type TemplateLiteralPart = string | AnyValidator;
+type ExtractValidatorTag<V> = V extends (value: never) => {
+    type: infer T;
+} ? T : never;
+type TagToTemplate<T> = T extends "string" ? string : T extends "number" ? number : T extends "boolean" ? boolean : T extends "bigint" ? bigint : ValidateType<T>;
+type PartToTemplate<P> = P extends string ? P : TagToTemplate<ExtractValidatorTag<P>>;
+/**
+ * Builds the template literal type produced by joining `Parts`. Each part is
+ * mapped to either its literal string value or to the runtime type that the
+ * corresponding validator accepts.
+ */
+export type BuildTemplateLiteral<Parts extends readonly TemplateLiteralPart[]> = Parts extends readonly [
+    infer Head,
+    ...infer Tail extends readonly TemplateLiteralPart[]
+] ? `${Extract<PartToTemplate<Head>, string | number | bigint | boolean>}${BuildTemplateLiteral<Tail>}` : "";
+/**
+ * Return type produced by a `templateLiteral` validator. Preserves the
+ * literal template string type through the `type` field so consumers like
+ * `union()`, `intersection()`, and `SchemaToInterface` can recover it.
+ * @template T - The inferred template literal type
+ */
+export interface TemplateLiteralReturnType<T extends string> {
+    validate: boolean;
+    message: string;
+    type: T;
+}
+/**
+ * Creates a validator that checks whether a value matches a template literal
+ * pattern. Each part is either a string literal that must appear verbatim or
+ * a primitive validator (string / number / boolean / bigint) that contributes
+ * a regex fragment.
+ * @template Parts - Tuple describing the template parts
+ * @param {Parts} parts - Tuple of literal strings and primitive validators
+ * @param {string} [message] - Custom error message for validation failure
+ * @returns {Function} - Validator function for template literal strings
+ */
+export declare const templateLiteral: <const Parts extends readonly TemplateLiteralPart[]>(parts: Parts, message?: string) => (value: BuildTemplateLiteral<Parts>) => TemplateLiteralReturnType<BuildTemplateLiteral<Parts>>;
+export {};

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

@@ -0,0 +1,114 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.templateLiteral = void 0;
+var _templateObject, _templateObject2, _templateObject3;
+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 _taggedTemplateLiteral(e, t) { return t || (t = e.slice(0)), Object.freeze(Object.defineProperties(e, { raw: { value: Object.freeze(t) } })); }
+/**
+ * Template literal validation core module
+ * Provides a validator that checks whether a string matches a template
+ * literal pattern composed of string fragments and primitive validators
+ * (string / number / boolean / bigint). The runtime check is performed by
+ * an auto-generated regular expression assembled from the parts, while the
+ * inferred type is the corresponding TypeScript template literal type.
+ */
+
+// biome-ignore lint/suspicious/noExplicitAny: validator signatures vary
+
+/**
+ * Allowed parts of a template literal definition. Each element is either a
+ * string literal that must appear verbatim, or a primitive validator whose
+ * accepted shape is converted to a regex fragment at construction time.
+ */
+
+/**
+ * Builds the template literal type produced by joining `Parts`. Each part is
+ * mapped to either its literal string value or to the runtime type that the
+ * corresponding validator accepts.
+ */
+
+/**
+ * Return type produced by a `templateLiteral` validator. Preserves the
+ * literal template string type through the `type` field so consumers like
+ * `union()`, `intersection()`, and `SchemaToInterface` can recover it.
+ * @template T - The inferred template literal type
+ */
+
+var escapeRegex = function escapeRegex(input) {
+  return input.replaceAll(/[$()*+.?[\\\]^{|}]/g, String.raw(_templateObject || (_templateObject = _taggedTemplateLiteral(["$&"], ["\\$&"]))));
+};
+var tagToPattern = function tagToPattern(tag) {
+  switch (tag) {
+    case "string":
+      {
+        return ".*?";
+      }
+    case "number":
+      {
+        return String.raw(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["-?(?:d+.d+|d+(?:.d*)?|.d+)"], ["-?(?:\\d+\\.\\d+|\\d+(?:\\.\\d*)?|\\.\\d+)"])));
+      }
+    case "boolean":
+      {
+        return "(?:true|false)";
+      }
+    case "bigint":
+      {
+        return String.raw(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["-?d+"], ["-?\\d+"])));
+      }
+    default:
+      {
+        return ".+?";
+      }
+  }
+};
+var detectValidatorTag = function detectValidatorTag(validator) {
+  var result = validator();
+  return result === null || result === void 0 ? void 0 : result.type;
+};
+
+/**
+ * Creates a validator that checks whether a value matches a template literal
+ * pattern. Each part is either a string literal that must appear verbatim or
+ * a primitive validator (string / number / boolean / bigint) that contributes
+ * a regex fragment.
+ * @template Parts - Tuple describing the template parts
+ * @param {Parts} parts - Tuple of literal strings and primitive validators
+ * @param {string} [message] - Custom error message for validation failure
+ * @returns {Function} - Validator function for template literal strings
+ */
+var templateLiteral = exports.templateLiteral = function templateLiteral(parts, message) {
+  var pattern = "^";
+  var _iterator = _createForOfIteratorHelper(parts),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var part = _step.value;
+      pattern += typeof part === "string" ? escapeRegex(part) : "(?:".concat(tagToPattern(detectValidatorTag(part)), ")");
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  pattern += "$";
+  var regex = new RegExp(pattern);
+  return function (value) {
+    if (typeof value !== "string" || !regex.test(value)) {
+      return {
+        validate: false,
+        message: message !== null && message !== void 0 ? message : "",
+        type: value
+      };
+    }
+    return {
+      validate: true,
+      message: "",
+      type: value
+    };
+  };
+};

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

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

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

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+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/type.d.ts

@@ -1,11 +1,12 @@
 export type _Types<T> = T extends string ? "string" : T extends number ? "number" : T extends boolean ? "boolean" : T;
 export type _Types2<T> = T extends undefined ? "undefined" : T extends null ? "null" : T;
+export type _Types3<T> = T extends bigint ? "bigint" : T;
 /**
  * Maps TypeScript types to their string literal representations
  * @template T - The type to map
- * @returns "string" for string, "number" for number, "boolean" for boolean, or the original type T otherwise
+ * @returns "string" for string, "number" for number, "boolean" for boolean, "bigint" for bigint, or the original type T otherwise
  */
-export type Types<T> = T extends string | number | boolean ? _Types<T> : T extends undefined | null ? _Types2<T> : T;
+export type Types<T> = T extends string | number | boolean ? _Types<T> : T extends undefined | null ? _Types2<T> : T extends bigint ? _Types3<T> : T;
 /**
  * Core validation result type including validation status, message, and type information
  * @template T - The type being validated
@@ -29,15 +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")
- * @returns The corresponding TypeScript type (string, number, boolean) or the original type T
+ * @template T - The string literal type name ("string", "number", "boolean", "bigint", "undefined", "null", "any", "unknown", "never")
+ * @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;
+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/unknown/core.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Unknown validation core module
+ * Provides a validator that accepts any value but exposes it as `unknown`
+ * to keep callers honest about narrowing before use.
+ */
+/**
+ * Return type produced by an `unknown` validator. Exposes the literal
+ * `"unknown"` tag through the `type` field so `ValidateType<"unknown">` can
+ * map it back to the `unknown` runtime type when consumed by downstream
+ * helpers.
+ */
+export interface UnknownReturnType {
+    validate: boolean;
+    message: string;
+    type: "unknown";
+}
+/**
+ * Creates a validator that accepts any value but typed as unknown
+ * @returns {Function} - Validator that always succeeds
+ */
+export declare const unknown: () => ((value: unknown) => UnknownReturnType);

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

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.unknown = void 0;
+/**
+ * Unknown validation core module
+ * Provides a validator that accepts any value but exposes it as `unknown`
+ * to keep callers honest about narrowing before use.
+ */
+
+/**
+ * Return type produced by an `unknown` validator. Exposes the literal
+ * `"unknown"` tag through the `type` field so `ValidateType<"unknown">` can
+ * map it back to the `unknown` runtime type when consumed by downstream
+ * helpers.
+ */
+
+var unknownValidator = function unknownValidator(_value) {
+  return {
+    validate: true,
+    message: "",
+    type: "unknown"
+  };
+};
+
+/**
+ * Creates a validator that accepts any value but typed as unknown
+ * @returns {Function} - Validator that always succeeds
+ */
+var unknown = exports.unknown = function unknown() {
+  return unknownValidator;
+};

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

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

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

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+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/package.json

@@ -226,5 +226,5 @@
   },
   "type": "module",
   "types": "module/index.d.ts",
-  "version": "2.19.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[]>;