umt 2.17.0 → 2.19.0

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

@@ -0,0 +1,9 @@
+import type { ValidateCoreReturnType } from "../../Validate/type";
+/**
+ * Creates an array validator that validates every element with a single validator
+ * @template T - Element type validated by the wrapped validator
+ * @param {Function} 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>(validator: (value: T) => ValidateCoreReturnType<T>, message?: string) => (values: T[]) => ValidateCoreReturnType<T[]>;

package/module/Validate/array/arrayOf.js

@@ -0,0 +1,35 @@
+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
+ * @param {Function} 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 const arrayOf = (validator, message) => {
+    return (values) => {
+        if (!isArray(values)) {
+            return {
+                validate: false,
+                message: message ?? "",
+                type: values,
+            };
+        }
+        for (const value of values) {
+            const result = validator(value);
+            if (!result.validate) {
+                return {
+                    validate: false,
+                    message: result.message,
+                    type: values,
+                };
+            }
+        }
+        return {
+            validate: true,
+            message: "",
+            type: values,
+        };
+    };
+};
+//# sourceMappingURL=arrayOf.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"arrayOf.js","sourceRoot":"","sources":["../../../src/Validate/array/arrayOf.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAG7C;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG,CACrB,SAAkD,EAClD,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"}

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

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

package/module/Validate/array/index.js

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

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

@@ -1,4 +1,5 @@
 export * from "./core";
 export * from "./intersection";
+export * from "./nullable";
 export * from "./optional";
 export * from "./union";

package/module/Validate/object/index.js

@@ -1,5 +1,6 @@
 export * from "./core";
 export * from "./intersection";
+export * from "./nullable";
 export * from "./optional";
 export * from "./union";
 //# sourceMappingURL=index.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/Validate/object/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAC;AACvB,cAAc,gBAAgB,CAAC;AAC/B,cAAc,YAAY,CAAC;AAC3B,cAAc,SAAS,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/Validate/object/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAC;AACvB,cAAc,gBAAgB,CAAC;AAC/B,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,SAAS,CAAC"}

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

@@ -1,6 +1,8 @@
 import type { UnionToIntersection } from "../../types/logic";
-import type { ValidateCoreReturnType } from "../../Validate/type";
-type ExtractValidatedType<V> = V extends (value: never) => ValidateCoreReturnType<infer T> ? T : never;
+import type { ValidateCoreReturnType, ValidateType } from "../../Validate/type";
+type ExtractValidatedType<V> = V extends (value: never) => {
+    type: infer T;
+} ? ValidateType<T> : never;
 /**
  * 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/Validate/object/intersection.js.map

@@ -1 +1 @@
-{"version":3,"file":"intersection.js","sourceRoot":"","sources":["../../../src/Validate/object/intersection.ts"],"names":[],"mappings":"AASA;;;;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":"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"}

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

@@ -0,0 +1,8 @@
+import type { ValidateCoreReturnType } from "../../Validate/type";
+/**
+ * Wraps a validator to accept null values
+ * @template T - The type of value the wrapped validator expects
+ * @param {Function} validator - Validator function to make nullable
+ * @returns {Function} - Validator that passes for null or delegates to the wrapped validator
+ */
+export declare const nullable: <T>(validator: (value: T) => ValidateCoreReturnType<T>) => ((value: T | null) => ValidateCoreReturnType<T | null>);

package/module/Validate/object/nullable.js

@@ -0,0 +1,21 @@
+/**
+ * Wraps a validator to accept null values
+ * @template T - The type of value the wrapped validator expects
+ * @param {Function} validator - Validator function to make nullable
+ * @returns {Function} - Validator that passes for null or delegates to the wrapped validator
+ */
+export const nullable = (validator) => {
+    const nullableValidator = (value) => {
+        if (value === null) {
+            return {
+                validate: true,
+                message: "",
+                type: "null",
+            };
+        }
+        const result = validator(value);
+        return result;
+    };
+    return nullableValidator;
+};
+//# sourceMappingURL=nullable.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"nullable.js","sourceRoot":"","sources":["../../../src/Validate/object/nullable.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,CACtB,SAAkD,EACO,EAAE;IAC3D,MAAM,iBAAiB,GAAG,CACxB,KAAe,EACmB,EAAE;QACpC,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;YACnB,OAAO;gBACL,QAAQ,EAAE,IAAI;gBACd,OAAO,EAAE,EAAE;gBACX,IAAI,EAAE,MAAM;aACb,CAAC;QACJ,CAAC;QACD,MAAM,MAAM,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC;QAChC,OAAO,MAAM,CAAC;IAChB,CAAC,CAAC;IAEF,OAAO,iBAAiB,CAAC;AAC3B,CAAC,CAAC"}

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

@@ -1,5 +1,7 @@
-import type { ValidateCoreReturnType } from "../../Validate/type";
-type ExtractValidatedType<V> = V extends (value: never) => ValidateCoreReturnType<infer T> ? T : never;
+import type { ValidateCoreReturnType, ValidateType } from "../../Validate/type";
+type ExtractValidatedType<V> = V extends (value: never) => {
+    type: infer T;
+} ? ValidateType<T> : never;
 /**
  * Creates a union validator that passes if any of the given validators pass
  * @param validators - Validator functions to compose as a union (logical OR)

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

@@ -1 +1 @@
-{"version":3,"file":"union.js","sourceRoot":"","sources":["../../../src/Validate/object/union.ts"],"names":[],"mappings":"AAQA;;;;GAIG;AACH,MAAM,CAAC,MAAM,KAAK,GAAG,CAGnB,GAAG,UAAmB,EACtB,EAAE;IACF,OAAO,CACL,KAAuC,EACmB,EAAE;QAC5D,IAAI,WAAW,GAAG,EAAE,CAAC;QACrB,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE,CAAC;YACnC,MAAM,MAAM,GACV,SAGD,CAAC,KAAK,CAAC,CAAC;YACT,IAAI,MAAM,CAAC,QAAQ,EAAE,CAAC;gBACpB,OAAO;oBACL,QAAQ,EAAE,IAAI;oBACd,OAAO,EAAE,EAAE;oBACX,IAAI,EAAE,KAA2D;iBAClE,CAAC;YACJ,CAAC;YACD,WAAW,GAAG,MAAM,CAAC,OAAO,CAAC;QAC/B,CAAC;QACD,OAAO;YACL,QAAQ,EAAE,KAAK;YACf,OAAO,EAAE,WAAW;YACpB,IAAI,EAAE,KAA2D;SAClE,CAAC;IACJ,CAAC,CAAC;AACJ,CAAC,CAAC"}
+{"version":3,"file":"union.js","sourceRoot":"","sources":["../../../src/Validate/object/union.ts"],"names":[],"mappings":"AAeA;;;;GAIG;AACH,MAAM,CAAC,MAAM,KAAK,GAAG,CAGnB,GAAG,UAAmB,EACtB,EAAE;IACF,OAAO,CACL,KAAuC,EACmB,EAAE;QAC5D,IAAI,WAAW,GAAG,EAAE,CAAC;QACrB,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE,CAAC;YACnC,MAAM,MAAM,GACV,SAGD,CAAC,KAAK,CAAC,CAAC;YACT,IAAI,MAAM,CAAC,QAAQ,EAAE,CAAC;gBACpB,OAAO;oBACL,QAAQ,EAAE,IAAI;oBACd,OAAO,EAAE,EAAE;oBACX,IAAI,EAAE,KAA2D;iBAClE,CAAC;YACJ,CAAC;YACD,WAAW,GAAG,MAAM,CAAC,OAAO,CAAC;QAC/B,CAAC;QACD,OAAO;YACL,QAAQ,EAAE,KAAK;YACf,OAAO,EAAE,WAAW;YACpB,IAAI,EAAE,KAA2D;SAClE,CAAC;IACJ,CAAC,CAAC;AACJ,CAAC,CAAC"}

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

@@ -4,5 +4,6 @@ export * from "./length";
 export * from "./minLength";
 export * from "./maxLength";
 export * from "./numberString";
+export * from "./oneOf";
 export * from "./regexMatch";
 export * from "./uuid";

package/module/Validate/string/index.js

@@ -4,6 +4,7 @@ export * from "./length";
 export * from "./minLength";
 export * from "./maxLength";
 export * from "./numberString";
+export * from "./oneOf";
 export * from "./regexMatch";
 export * from "./uuid";
 //# sourceMappingURL=index.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/Validate/string/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAC;AACvB,cAAc,iBAAiB,CAAC;AAChC,cAAc,UAAU,CAAC;AACzB,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,cAAc,CAAC;AAC7B,cAAc,QAAQ,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/Validate/string/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAC;AACvB,cAAc,iBAAiB,CAAC;AAChC,cAAc,UAAU,CAAC;AACzB,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,SAAS,CAAC;AACxB,cAAc,cAAc,CAAC;AAC7B,cAAc,QAAQ,CAAC"}

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

@@ -0,0 +1,32 @@
+/**
+ * String validation module for literal union (allowed values) check
+ * Provides validation functionality for checking if a string is one of the
+ * allowed literal values, useful for validating string literal union types
+ * 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.
+ */
+/**
+ * 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`.
+ */
+export interface OneOfReturnType<T extends string> {
+    validate: boolean;
+    message: string;
+    type: T;
+}
+/**
+ * Creates a top-level validator that checks if a string value is one of the
+ * given allowed literal values. The literal union is captured via `const T`
+ * and exposed through the `OneOfReturnType<T[number]>` return type.
+ * @template T - The tuple of allowed string literals
+ * @param {T} values - The tuple of allowed string values
+ * @param {string} [message] - Custom error message for validation failure
+ * @returns A validator function from `string` to `OneOfReturnType<T[number]>`
+ */
+export declare const oneOf: <const T extends readonly string[]>(values: T, message?: string) => (value: string) => OneOfReturnType<T[number]>;

package/module/Validate/string/oneOf.js

@@ -0,0 +1,32 @@
+/**
+ * String validation module for literal union (allowed values) check
+ * Provides validation functionality for checking if a string is one of the
+ * allowed literal values, useful for validating string literal union types
+ * 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.
+ */
+/**
+ * Creates a top-level validator that checks if a string value is one of the
+ * given allowed literal values. The literal union is captured via `const T`
+ * and exposed through the `OneOfReturnType<T[number]>` return type.
+ * @template T - The tuple of allowed string literals
+ * @param {T} values - The tuple of allowed string values
+ * @param {string} [message] - Custom error message for validation failure
+ * @returns A validator function from `string` to `OneOfReturnType<T[number]>`
+ */
+export const oneOf = (values, message) => {
+    const allowed = new Set(values);
+    return (value) => {
+        const isValid = allowed.has(value);
+        return {
+            validate: isValid,
+            message: isValid ? "" : (message ?? ""),
+            type: value,
+        };
+    };
+};
+//# sourceMappingURL=oneOf.js.map

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

@@ -0,0 +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"}

package/module/Validate/type.d.ts

@@ -37,7 +37,7 @@ export type _ValidateType2<T> = T extends "undefined" ? undefined : T extends "n
  * @returns The corresponding TypeScript type (string, number, boolean) or the original type T
  */
 export type ValidateType<T> = T extends "string" | "number" | "boolean" ? _ValidateType<T> : T extends "undefined" | "null" ? _ValidateType2<T> : T;
-export type SchemaToInterface<T extends (value: any) => ValidateCoreReturnType<any>> = ReturnType<T>["type"];
+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];

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

@@ -0,0 +1,9 @@
+import type { ValidateCoreReturnType } from "../../Validate/type";
+/**
+ * Creates an array validator that validates every element with a single validator
+ * @template T - Element type validated by the wrapped validator
+ * @param {Function} 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>(validator: (value: T) => ValidateCoreReturnType<T>, message?: string) => (values: T[]) => ValidateCoreReturnType<T[]>;

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

@@ -0,0 +1,52 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.arrayOf = void 0;
+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; }
+/**
+ * Creates an array validator that validates every element with a single validator
+ * @template T - Element type validated by the wrapped validator
+ * @param {Function} 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
+ */
+var arrayOf = exports.arrayOf = function arrayOf(validator, message) {
+  return function (values) {
+    if (!(0, _isArray.isArray)(values)) {
+      return {
+        validate: false,
+        message: message !== null && message !== void 0 ? message : "",
+        type: values
+      };
+    }
+    var _iterator = _createForOfIteratorHelper(values),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var value = _step.value;
+        var result = validator(value);
+        if (!result.validate) {
+          return {
+            validate: false,
+            message: result.message,
+            type: values
+          };
+        }
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+    return {
+      validate: true,
+      message: "",
+      type: values
+    };
+  };
+};

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

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

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

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

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

@@ -1,4 +1,5 @@
 export * from "./core";
 export * from "./intersection";
+export * from "./nullable";
 export * from "./optional";
 export * from "./union";

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

@@ -25,6 +25,17 @@ Object.keys(_intersection).forEach(function (key) {
     }
   });
 });
+var _nullable = require("./nullable");
+Object.keys(_nullable).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _nullable[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _nullable[key];
+    }
+  });
+});
 var _optional = require("./optional");
 Object.keys(_optional).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;

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

@@ -1,6 +1,8 @@
 import type { UnionToIntersection } from "../../types/logic";
-import type { ValidateCoreReturnType } from "../../Validate/type";
-type ExtractValidatedType<V> = V extends (value: never) => ValidateCoreReturnType<infer T> ? T : never;
+import type { ValidateCoreReturnType, ValidateType } from "../../Validate/type";
+type ExtractValidatedType<V> = V extends (value: never) => {
+    type: infer T;
+} ? ValidateType<T> : never;
 /**
  * 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/object/intersection.js

@@ -4,6 +4,12 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.intersection = void 0;
+// 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
+// intersection without being collapsed by `Types<T>`.
+
 /**
  * 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/object/nullable.d.ts

@@ -0,0 +1,8 @@
+import type { ValidateCoreReturnType } from "../../Validate/type";
+/**
+ * Wraps a validator to accept null values
+ * @template T - The type of value the wrapped validator expects
+ * @param {Function} validator - Validator function to make nullable
+ * @returns {Function} - Validator that passes for null or delegates to the wrapped validator
+ */
+export declare const nullable: <T>(validator: (value: T) => ValidateCoreReturnType<T>) => ((value: T | null) => ValidateCoreReturnType<T | null>);

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

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.nullable = void 0;
+/**
+ * Wraps a validator to accept null values
+ * @template T - The type of value the wrapped validator expects
+ * @param {Function} validator - Validator function to make nullable
+ * @returns {Function} - Validator that passes for null or delegates to the wrapped validator
+ */
+var nullable = exports.nullable = function nullable(validator) {
+  var nullableValidator = function nullableValidator(value) {
+    if (value === null) {
+      return {
+        validate: true,
+        message: "",
+        type: "null"
+      };
+    }
+    var result = validator(value);
+    return result;
+  };
+  return nullableValidator;
+};

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

@@ -1,5 +1,7 @@
-import type { ValidateCoreReturnType } from "../../Validate/type";
-type ExtractValidatedType<V> = V extends (value: never) => ValidateCoreReturnType<infer T> ? T : never;
+import type { ValidateCoreReturnType, ValidateType } from "../../Validate/type";
+type ExtractValidatedType<V> = V extends (value: never) => {
+    type: infer T;
+} ? ValidateType<T> : never;
 /**
  * Creates a union validator that passes if any of the given validators pass
  * @param validators - Validator functions to compose as a union (logical OR)

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

@@ -4,6 +4,12 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.union = void 0;
+// 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 union
+// without being collapsed by `Types<T>`.
+
 /**
  * Creates a union validator that passes if any of the given validators pass
  * @param validators - Validator functions to compose as a union (logical OR)

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

@@ -4,5 +4,6 @@ export * from "./length";
 export * from "./minLength";
 export * from "./maxLength";
 export * from "./numberString";
+export * from "./oneOf";
 export * from "./regexMatch";
 export * from "./uuid";

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

@@ -69,6 +69,17 @@ Object.keys(_numberString).forEach(function (key) {
     }
   });
 });
+var _oneOf = require("./oneOf");
+Object.keys(_oneOf).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _oneOf[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _oneOf[key];
+    }
+  });
+});
 var _regexMatch = require("./regexMatch");
 Object.keys(_regexMatch).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;

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

@@ -0,0 +1,32 @@
+/**
+ * String validation module for literal union (allowed values) check
+ * Provides validation functionality for checking if a string is one of the
+ * allowed literal values, useful for validating string literal union types
+ * 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.
+ */
+/**
+ * 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`.
+ */
+export interface OneOfReturnType<T extends string> {
+    validate: boolean;
+    message: string;
+    type: T;
+}
+/**
+ * Creates a top-level validator that checks if a string value is one of the
+ * given allowed literal values. The literal union is captured via `const T`
+ * and exposed through the `OneOfReturnType<T[number]>` return type.
+ * @template T - The tuple of allowed string literals
+ * @param {T} values - The tuple of allowed string values
+ * @param {string} [message] - Custom error message for validation failure
+ * @returns A validator function from `string` to `OneOfReturnType<T[number]>`
+ */
+export declare const oneOf: <const T extends readonly string[]>(values: T, message?: string) => (value: string) => OneOfReturnType<T[number]>;

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

@@ -0,0 +1,45 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.oneOf = void 0;
+/**
+ * String validation module for literal union (allowed values) check
+ * Provides validation functionality for checking if a string is one of the
+ * allowed literal values, useful for validating string literal union types
+ * 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.
+ */
+
+/**
+ * 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`.
+ */
+
+/**
+ * Creates a top-level validator that checks if a string value is one of the
+ * given allowed literal values. The literal union is captured via `const T`
+ * and exposed through the `OneOfReturnType<T[number]>` return type.
+ * @template T - The tuple of allowed string literals
+ * @param {T} values - The tuple of allowed string values
+ * @param {string} [message] - Custom error message for validation failure
+ * @returns A validator function from `string` to `OneOfReturnType<T[number]>`
+ */
+var oneOf = exports.oneOf = function oneOf(values, message) {
+  var allowed = new Set(values);
+  return function (value) {
+    var isValid = allowed.has(value);
+    return {
+      validate: isValid,
+      message: isValid ? "" : message !== null && message !== void 0 ? message : "",
+      type: value
+    };
+  };
+};

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

@@ -37,7 +37,7 @@ export type _ValidateType2<T> = T extends "undefined" ? undefined : T extends "n
  * @returns The corresponding TypeScript type (string, number, boolean) or the original type T
  */
 export type ValidateType<T> = T extends "string" | "number" | "boolean" ? _ValidateType<T> : T extends "undefined" | "null" ? _ValidateType2<T> : T;
-export type SchemaToInterface<T extends (value: any) => ValidateCoreReturnType<any>> = ReturnType<T>["type"];
+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];