umt 2.18.0 → 2.20.0

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

@@ -0,0 +1,81 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.map = void 0;
+function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+/**
+ * Map validation core module
+ * Provides validation for `Map` instances. The validator can optionally
+ * delegate to per-entry validators for keys and values, mirroring how
+ * `arrayOf()` validates each element of an array.
+ */
+
+/**
+ * Creates a Map validator. The validator can optionally accept per-entry key
+ * and value validators that are applied to every entry of the map. When the
+ * value-side validator is provided, the entry validators short-circuit on the
+ * first failure and surface the failing message, mirroring `arrayOf()`.
+ * @template KV - Validator for the map key
+ * @template VV - Validator for the map value
+ * @param {KV} [keyValidator] - Validator applied to every key
+ * @param {VV} [valueValidator] - Validator applied to every value
+ * @param {string} [message] - Custom error message for type validation
+ * @returns {Function} - Validator function for Map instances
+ */
+var map = exports.map = function map(keyValidator, valueValidator, message) {
+  return function (value) {
+    if (!(value instanceof Map)) {
+      return {
+        validate: false,
+        message: message !== null && message !== void 0 ? message : "",
+        type: value
+      };
+    }
+    var _iterator = _createForOfIteratorHelper(value),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var _step$value = _slicedToArray(_step.value, 2),
+          entryKey = _step$value[0],
+          entryValue = _step$value[1];
+        if (keyValidator) {
+          var keyResult = keyValidator(entryKey);
+          if (!keyResult.validate) {
+            return {
+              validate: false,
+              message: keyResult.message,
+              type: value
+            };
+          }
+        }
+        if (valueValidator) {
+          var valueResult = valueValidator(entryValue);
+          if (!valueResult.validate) {
+            return {
+              validate: false,
+              message: valueResult.message,
+              type: value
+            };
+          }
+        }
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+    return {
+      validate: true,
+      message: "",
+      type: value
+    };
+  };
+};

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

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

package/module/es5/Validate/map/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/never/core.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Never validation core module
+ * Provides a validator that fails for every input, useful for marking
+ * positions in a schema that must never be filled (for example, exhaustive
+ * union members that should be unreachable at the type level).
+ */
+/**
+ * Return type produced by a `never` validator. Exposes the literal `"never"`
+ * tag through the `type` field so `ValidateType<"never">` can map it back to
+ * the `never` runtime type when consumed by downstream helpers.
+ */
+export interface NeverReturnType {
+    validate: boolean;
+    message: string;
+    type: "never";
+}
+/**
+ * Creates a validator that always fails
+ * @param {string} [message] - Custom error message for validation failure
+ * @returns {Function} - Validator that always returns a failing result
+ */
+export declare const never: (message?: string) => ((value: any) => NeverReturnType);

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

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.never = void 0;
+/**
+ * Never validation core module
+ * Provides a validator that fails for every input, useful for marking
+ * positions in a schema that must never be filled (for example, exhaustive
+ * union members that should be unreachable at the type level).
+ */
+
+/**
+ * Return type produced by a `never` validator. Exposes the literal `"never"`
+ * tag through the `type` field so `ValidateType<"never">` can map it back to
+ * the `never` runtime type when consumed by downstream helpers.
+ */
+
+/**
+ * Creates a validator that always fails
+ * @param {string} [message] - Custom error message for validation failure
+ * @returns {Function} - Validator that always returns a failing result
+ */
+// biome-ignore lint/suspicious/noExplicitAny: never() is widened to accept any input from union/intersection
+var never = exports.never = function never(message) {
+  // biome-ignore lint/suspicious/noExplicitAny: signature mirrors the public type
+  return function (_value) {
+    return {
+      validate: false,
+      message: message !== null && message !== void 0 ? message : "",
+      type: "never"
+    };
+  };
+};

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

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

package/module/es5/Validate/never/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/object/core.d.ts

@@ -4,13 +4,31 @@
  */
 import type { PickPartial } from "../../types/object";
 import type { OptionalKeys, ValidateCoreReturnType, ValidateType } from "../../Validate/type";
+/**
+ * Shape map describing per-property validators consumed by `object()`
+ */
+export interface ObjectShape {
+    [key: string]: (value: any) => ValidateCoreReturnType<unknown>;
+}
+/**
+ * Object validator augmented with the original `shape` map. The shape map is
+ * exposed so derived helpers such as `pick()`, `omit()`, `partial()`, and
+ * `required()` can compose new object validators from existing ones.
+ */
+export type ObjectValidator<T extends ObjectShape, U = {
+    [key in keyof T]: ValidateType<ReturnType<T[key]>["type"]>;
+}> = ((value: {
+    [key in keyof PickPartial<U, OptionalKeys<U>>]: PickPartial<U, OptionalKeys<U>>[key];
+}) => ValidateCoreReturnType<{
+    [key in keyof PickPartial<U, OptionalKeys<U>>]: PickPartial<U, OptionalKeys<U>>[key];
+}>) & {
+    shape: T;
+};
 /**
  * Creates an object validator with property-specific validation rules
  * @template T - Object type containing validation functions for each property
  * @param {T} [option] - Object containing validation functions for each property
  * @param {string} [message] - Custom error message for object type validation
- * @returns {Function} - Validator function that checks if the value is an object and validates its properties
+ * @returns {ObjectValidator<T>} - Validator function with `.shape` attached so it can compose with `pick()`, `omit()`, `partial()`, and `required()`
  */
-export declare const object: <T extends {
-    [key: string]: (value: any) => ValidateCoreReturnType<any>;
-}, U = { [key in keyof T]: ValidateType<ReturnType<T[key]>["type"]>; }>(option?: T, message?: string) => (value: { [key in keyof PickPartial<U, OptionalKeys<U>>]: PickPartial<U, OptionalKeys<U>>[key]; }) => ValidateCoreReturnType<{ [key in keyof PickPartial<U, OptionalKeys<U>>]: PickPartial<U, OptionalKeys<U>>[key]; }>;
+export declare const object: <T extends ObjectShape>(option?: T, message?: string) => ObjectValidator<T>;

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

@@ -10,17 +10,27 @@ var _isDictionaryObject = require("../../Validate/isDictionaryObject");
  * Provides validation functionality for objects with type-specific validation rules for each property
  */
 
+/**
+ * Shape map describing per-property validators consumed by `object()`
+ */
+
+/**
+ * Object validator augmented with the original `shape` map. The shape map is
+ * exposed so derived helpers such as `pick()`, `omit()`, `partial()`, and
+ * `required()` can compose new object validators from existing ones.
+ */
+
 /**
  * Creates an object validator with property-specific validation rules
  * @template T - Object type containing validation functions for each property
  * @param {T} [option] - Object containing validation functions for each property
  * @param {string} [message] - Custom error message for object type validation
- * @returns {Function} - Validator function that checks if the value is an object and validates its properties
+ * @returns {ObjectValidator<T>} - Validator function with `.shape` attached so it can compose with `pick()`, `omit()`, `partial()`, and `required()`
  */
 var object = exports.object = function object() {
   var option = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
   var message = arguments.length > 1 ? arguments[1] : undefined;
-  return function (value) {
+  var validator = function validator(value) {
     if (!(0, _isDictionaryObject.isDictionaryObject)(value)) {
       return {
         validate: false,
@@ -47,4 +57,6 @@ var object = exports.object = function object() {
       type: value
     };
   };
+  validator.shape = option;
+  return validator;
 };

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

@@ -1,5 +1,9 @@
 export * from "./core";
 export * from "./intersection";
 export * from "./nullable";
+export * from "./omit";
 export * from "./optional";
+export * from "./partial";
+export * from "./pick";
+export * from "./required";
 export * from "./union";

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

@@ -36,6 +36,17 @@ Object.keys(_nullable).forEach(function (key) {
     }
   });
 });
+var _omit = require("./omit");
+Object.keys(_omit).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _omit[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _omit[key];
+    }
+  });
+});
 var _optional = require("./optional");
 Object.keys(_optional).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
@@ -47,6 +58,39 @@ Object.keys(_optional).forEach(function (key) {
     }
   });
 });
+var _partial = require("./partial");
+Object.keys(_partial).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _partial[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _partial[key];
+    }
+  });
+});
+var _pick = require("./pick");
+Object.keys(_pick).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _pick[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _pick[key];
+    }
+  });
+});
+var _required = require("./required");
+Object.keys(_required).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _required[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _required[key];
+    }
+  });
+});
 var _union = require("./union");
 Object.keys(_union).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;

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

@@ -1,8 +1,18 @@
-import type { ValidateCoreReturnType } from "../../Validate/type";
+interface NullReturn {
+    validate: boolean;
+    message: string;
+    type: "null";
+}
 /**
  * Wraps a validator to accept null values
  * @template T - The type of value the wrapped validator expects
+ * @template R - The return type of the wrapped validator (preserved so the inner type tag flows through)
  * @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>);
+export declare const nullable: <T, R extends {
+    type: unknown;
+    message: string;
+    validate: boolean;
+}>(validator: (value: T) => R) => ((value: T | null) => R | NullReturn);
+export {};

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

@@ -7,6 +7,7 @@ exports.nullable = void 0;
 /**
  * Wraps a validator to accept null values
  * @template T - The type of value the wrapped validator expects
+ * @template R - The return type of the wrapped validator (preserved so the inner type tag flows through)
  * @param {Function} validator - Validator function to make nullable
  * @returns {Function} - Validator that passes for null or delegates to the wrapped validator
  */
@@ -19,8 +20,7 @@ var nullable = exports.nullable = function nullable(validator) {
         type: "null"
       };
     }
-    var result = validator(value);
-    return result;
+    return validator(value);
   };
   return nullableValidator;
 };

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

@@ -0,0 +1,22 @@
+/**
+ * Object validation - omit
+ * Returns a new object validator that drops the specified keys from the
+ * source validator. Mirrors `Omit<T, K>` at the type level so consumers
+ * like `union()`, `intersection()`, and `SchemaToInterface` see the
+ * narrowed shape.
+ *
+ * The function is exported as `omit_` because the top-level `Object` module
+ * already exposes an `omit` runtime helper.
+ */
+import { type ObjectShape, type ObjectValidator } from "./core";
+/**
+ * Removes the given keys from an existing object validator and returns a new
+ * object validator covering the remaining keys.
+ * @template T - Original object shape
+ * @template K - Tuple of keys to omit from the original shape
+ * @param {ObjectValidator<T>} validator - Source object validator
+ * @param {K} keys - Keys to drop from the new validator
+ * @param {string} [message] - Custom error message for the omitted validator
+ * @returns {ObjectValidator<Omit<T, K[number]>>} - New validator without omitted keys
+ */
+export declare const omit_: <T extends ObjectShape, K extends readonly (keyof T)[]>(validator: ObjectValidator<T>, keys: K, message?: string) => ObjectValidator<Omit<T, K[number]>>;

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

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.omit_ = void 0;
+var _core = require("./core");
+/**
+ * Object validation - omit
+ * Returns a new object validator that drops the specified keys from the
+ * source validator. Mirrors `Omit<T, K>` at the type level so consumers
+ * like `union()`, `intersection()`, and `SchemaToInterface` see the
+ * narrowed shape.
+ *
+ * The function is exported as `omit_` because the top-level `Object` module
+ * already exposes an `omit` runtime helper.
+ */
+
+/**
+ * Removes the given keys from an existing object validator and returns a new
+ * object validator covering the remaining keys.
+ * @template T - Original object shape
+ * @template K - Tuple of keys to omit from the original shape
+ * @param {ObjectValidator<T>} validator - Source object validator
+ * @param {K} keys - Keys to drop from the new validator
+ * @param {string} [message] - Custom error message for the omitted validator
+ * @returns {ObjectValidator<Omit<T, K[number]>>} - New validator without omitted keys
+ */
+var omit_ = exports.omit_ = function omit_(validator, keys, message) {
+  var sourceShape = validator.shape;
+  var omittedKeys = new Set(keys);
+  var nextShape = {};
+  for (var key in sourceShape) {
+    if (!omittedKeys.has(key)) {
+      nextShape[key] = sourceShape[key];
+    }
+  }
+  return (0, _core.object)(nextShape, message);
+};

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

@@ -1,8 +1,36 @@
-import type { ValidateCoreReturnType } from "../../Validate/type";
+interface UndefinedReturn {
+    validate: boolean;
+    message: string;
+    type: "undefined";
+}
+/**
+ * Optional validator augmented with a reference to the wrapped validator,
+ * used by `required()` to unwrap optional layers when rebuilding a shape
+ * @template T - The type of value the wrapped validator expects
+ * @template R - The return type of the wrapped validator (preserved so the inner type tag flows through)
+ */
+export type OptionalValidator<T, R extends {
+    type: unknown;
+    message: string;
+    validate: boolean;
+} = {
+    type: unknown;
+    message: string;
+    validate: boolean;
+}> = ((value?: T) => R | UndefinedReturn) & {
+    inner: (value: T) => R;
+    isOptional: true;
+};
 /**
  * Wraps a validator to accept undefined values
  * @template T - The type of value the wrapped validator expects
+ * @template R - The return type of the wrapped validator (preserved so the inner type tag flows through)
  * @param {Function} validator - Validator function to make optional
- * @returns {Function} - Validator that passes for undefined or delegates to the wrapped validator
+ * @returns {OptionalValidator<T, R>} - Validator that passes for undefined or delegates to the wrapped validator
  */
-export declare const optional: <T>(validator: (value: T) => ValidateCoreReturnType<T>) => ((value?: T) => ValidateCoreReturnType<T | undefined>);
+export declare const optional: <T, R extends {
+    type: unknown;
+    message: string;
+    validate: boolean;
+}>(validator: (value: T) => R) => OptionalValidator<T, R>;
+export {};

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

@@ -4,11 +4,19 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.optional = void 0;
+/**
+ * Optional validator augmented with a reference to the wrapped validator,
+ * used by `required()` to unwrap optional layers when rebuilding a shape
+ * @template T - The type of value the wrapped validator expects
+ * @template R - The return type of the wrapped validator (preserved so the inner type tag flows through)
+ */
+
 /**
  * Wraps a validator to accept undefined values
  * @template T - The type of value the wrapped validator expects
+ * @template R - The return type of the wrapped validator (preserved so the inner type tag flows through)
  * @param {Function} validator - Validator function to make optional
- * @returns {Function} - Validator that passes for undefined or delegates to the wrapped validator
+ * @returns {OptionalValidator<T, R>} - Validator that passes for undefined or delegates to the wrapped validator
  */
 var optional = exports.optional = function optional(validator) {
   var optionalValidator = function optionalValidator(value) {
@@ -19,8 +27,9 @@ var optional = exports.optional = function optional(validator) {
         type: "undefined"
       };
     }
-    var result = validator(value);
-    return result;
+    return validator(value);
   };
+  optionalValidator.inner = validator;
+  optionalValidator.isOptional = true;
   return optionalValidator;
 };

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

@@ -0,0 +1,25 @@
+/**
+ * Object validation - partial
+ * Returns a new object validator where every key is wrapped in `optional()`,
+ * mirroring `Partial<T>` at the type level so consumers see all properties as
+ * optional.
+ */
+import { type ObjectShape, type ObjectValidator } from "./core";
+import { type OptionalValidator } from "./optional";
+type PartialShape<T extends ObjectShape> = {
+    [K in keyof T]: OptionalValidator<Parameters<T[K]>[0], ReturnType<T[K]> extends {
+        type: unknown;
+        message: string;
+        validate: boolean;
+    } ? ReturnType<T[K]> : never>;
+};
+/**
+ * Wraps every property validator of `validator` with `optional()`. Validators
+ * that are already optional are kept as-is so the wrapper stays idempotent.
+ * @template T - Original object shape
+ * @param {ObjectValidator<T>} validator - Source object validator
+ * @param {string} [message] - Custom error message for the new validator
+ * @returns {ObjectValidator<PartialShape<T>>} - New validator where every key accepts undefined
+ */
+export declare const partial: <T extends ObjectShape>(validator: ObjectValidator<T>, message?: string) => ObjectValidator<PartialShape<T>>;
+export {};

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

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.partial = void 0;
+var _core = require("./core");
+var _optional = require("./optional");
+/**
+ * Object validation - partial
+ * Returns a new object validator where every key is wrapped in `optional()`,
+ * mirroring `Partial<T>` at the type level so consumers see all properties as
+ * optional.
+ */
+
+/**
+ * Wraps every property validator of `validator` with `optional()`. Validators
+ * that are already optional are kept as-is so the wrapper stays idempotent.
+ * @template T - Original object shape
+ * @param {ObjectValidator<T>} validator - Source object validator
+ * @param {string} [message] - Custom error message for the new validator
+ * @returns {ObjectValidator<PartialShape<T>>} - New validator where every key accepts undefined
+ */
+var partial = exports.partial = function partial(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];
+    nextShape[key] = current.isOptional === true ? current : (0, _optional.optional)(current);
+  }
+  return (0, _core.object)(nextShape, message);
+};

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

@@ -0,0 +1,21 @@
+/**
+ * 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.
+ */
+import { type ObjectShape, type ObjectValidator } from "./core";
+/**
+ * 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
+ */
+export declare const pick_: <T extends ObjectShape, K extends readonly (keyof T)[]>(validator: ObjectValidator<T>, keys: K, message?: string) => ObjectValidator<Pick<T, K[number]>>;

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 {};