umt 2.19.0 → 3.0.0

package/module/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/Validate/set/core.js

@@ -0,0 +1,47 @@
+/**
+ * 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 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 const set_ = (itemValidator, message) => {
+    return (value) => {
+        if (!(value instanceof Set)) {
+            return {
+                validate: false,
+                message: message ?? "",
+                type: value,
+            };
+        }
+        if (itemValidator) {
+            for (const item of value) {
+                const result = itemValidator(item);
+                if (!result.validate) {
+                    return {
+                        validate: false,
+                        message: result.message,
+                        type: value,
+                    };
+                }
+            }
+        }
+        return {
+            validate: true,
+            message: "",
+            type: value,
+        };
+    };
+};
+//# sourceMappingURL=core.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"core.js","sourceRoot":"","sources":["../../../src/Validate/set/core.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAQH;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,IAAI,GAAG,CAOlB,aAAkB,EAClB,OAAgB,EAChB,EAAE;IACF,OAAO,CAAC,KAAa,EAAkC,EAAE;QACvD,IAAI,CAAC,CAAC,KAAK,YAAY,GAAG,CAAC,EAAE,CAAC;YAC5B,OAAO;gBACL,QAAQ,EAAE,KAAK;gBACf,OAAO,EAAE,OAAO,IAAI,EAAE;gBACtB,IAAI,EAAE,KAAK;aACZ,CAAC;QACJ,CAAC;QACD,IAAI,aAAa,EAAE,CAAC;YAClB,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;gBACzB,MAAM,MAAM,GACV,aAID,CAAC,IAAI,CAAC,CAAC;gBACR,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC;oBACrB,OAAO;wBACL,QAAQ,EAAE,KAAK;wBACf,OAAO,EAAE,MAAM,CAAC,OAAO;wBACvB,IAAI,EAAE,KAAK;qBACZ,CAAC;gBACJ,CAAC;YACH,CAAC;QACH,CAAC;QACD,OAAO;YACL,QAAQ,EAAE,IAAI;YACd,OAAO,EAAE,EAAE;YACX,IAAI,EAAE,KAAK;SACZ,CAAC;IACJ,CAAC,CAAC;AACJ,CAAC,CAAC"}

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

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

package/module/Validate/set/index.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/Validate/set/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,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/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/Validate/templateLiteral/core.js

@@ -0,0 +1,68 @@
+/**
+ * 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.
+ */
+const escapeRegex = (input) => input.replaceAll(/[$()*+.?[\\\]^{|}]/g, String.raw `\$&`);
+const tagToPattern = (tag) => {
+    switch (tag) {
+        case "string": {
+            return ".*?";
+        }
+        case "number": {
+            return String.raw `-?(?:\d+\.\d+|\d+(?:\.\d*)?|\.\d+)`;
+        }
+        case "boolean": {
+            return "(?:true|false)";
+        }
+        case "bigint": {
+            return String.raw `-?\d+`;
+        }
+        default: {
+            return ".+?";
+        }
+    }
+};
+const detectValidatorTag = (validator) => {
+    const result = validator();
+    return 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
+ */
+export const templateLiteral = (parts, message) => {
+    let pattern = "^";
+    for (const part of parts) {
+        pattern +=
+            typeof part === "string"
+                ? escapeRegex(part)
+                : `(?:${tagToPattern(detectValidatorTag(part))})`;
+    }
+    pattern += "$";
+    const regex = new RegExp(pattern);
+    return (value) => {
+        if (typeof value !== "string" || !regex.test(value)) {
+            return {
+                validate: false,
+                message: message ?? "",
+                type: value,
+            };
+        }
+        return {
+            validate: true,
+            message: "",
+            type: value,
+        };
+    };
+};
+//# sourceMappingURL=core.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"core.js","sourceRoot":"","sources":["../../../src/Validate/templateLiteral/core.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAyDH,MAAM,WAAW,GAAG,CAAC,KAAa,EAAU,EAAE,CAC5C,KAAK,CAAC,UAAU,CAAC,qBAAqB,EAAE,MAAM,CAAC,GAAG,CAAA,KAAK,CAAC,CAAC;AAE3D,MAAM,YAAY,GAAG,CAAC,GAAY,EAAU,EAAE;IAC5C,QAAQ,GAAG,EAAE,CAAC;QACZ,KAAK,QAAQ,CAAC,CAAC,CAAC;YACd,OAAO,KAAK,CAAC;QACf,CAAC;QACD,KAAK,QAAQ,CAAC,CAAC,CAAC;YACd,OAAO,MAAM,CAAC,GAAG,CAAA,oCAAoC,CAAC;QACxD,CAAC;QACD,KAAK,SAAS,CAAC,CAAC,CAAC;YACf,OAAO,gBAAgB,CAAC;QAC1B,CAAC;QACD,KAAK,QAAQ,CAAC,CAAC,CAAC;YACd,OAAO,MAAM,CAAC,GAAG,CAAA,OAAO,CAAC;QAC3B,CAAC;QACD,OAAO,CAAC,CAAC,CAAC;YACR,OAAO,KAAK,CAAC;QACf,CAAC;IACH,CAAC;AACH,CAAC,CAAC;AAEF,MAAM,kBAAkB,GAAG,CAAC,SAAuB,EAAW,EAAE;IAC9D,MAAM,MAAM,GAAG,SAAS,EAAE,CAAC;IAC3B,OAAO,MAAM,EAAE,IAAI,CAAC;AACtB,CAAC,CAAC;AAEF;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,CAG7B,KAAY,EACZ,OAAgB,EAChB,EAAE;IACF,IAAI,OAAO,GAAG,GAAG,CAAC;IAClB,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,OAAO;YACL,OAAO,IAAI,KAAK,QAAQ;gBACtB,CAAC,CAAC,WAAW,CAAC,IAAI,CAAC;gBACnB,CAAC,CAAC,MAAM,YAAY,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC;IACxD,CAAC;IACD,OAAO,IAAI,GAAG,CAAC;IACf,MAAM,KAAK,GAAG,IAAI,MAAM,CAAC,OAAO,CAAC,CAAC;IAElC,OAAO,CACL,KAAkC,EACsB,EAAE;QAC1D,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;YACpD,OAAO;gBACL,QAAQ,EAAE,KAAK;gBACf,OAAO,EAAE,OAAO,IAAI,EAAE;gBACtB,IAAI,EAAE,KAAK;aACZ,CAAC;QACJ,CAAC;QACD,OAAO;YACL,QAAQ,EAAE,IAAI;YACd,OAAO,EAAE,EAAE;YACX,IAAI,EAAE,KAAK;SACZ,CAAC;IACJ,CAAC,CAAC;AACJ,CAAC,CAAC"}

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

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

package/module/Validate/templateLiteral/index.js

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

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

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

package/module/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/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/Validate/unknown/core.js

@@ -0,0 +1,16 @@
+/**
+ * Unknown validation core module
+ * Provides a validator that accepts any value but exposes it as `unknown`
+ * to keep callers honest about narrowing before use.
+ */
+const unknownValidator = (_value) => ({
+    validate: true,
+    message: "",
+    type: "unknown",
+});
+/**
+ * Creates a validator that accepts any value but typed as unknown
+ * @returns {Function} - Validator that always succeeds
+ */
+export const unknown = () => unknownValidator;
+//# sourceMappingURL=core.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"core.js","sourceRoot":"","sources":["../../../src/Validate/unknown/core.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAcH,MAAM,gBAAgB,GAAG,CAAC,MAAe,EAAqB,EAAE,CAAC,CAAC;IAChE,QAAQ,EAAE,IAAI;IACd,OAAO,EAAE,EAAE;IACX,IAAI,EAAE,SAAS;CAChB,CAAC,CAAC;AAEH;;;GAGG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG,GAA4C,EAAE,CACnE,gBAAgB,CAAC"}

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

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

package/module/Validate/unknown/index.js

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

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

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

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

@@ -0,0 +1,21 @@
+/**
+ * Any validation core module
+ * Provides a validator that accepts any value, useful when a position in a
+ * schema needs to remain wide open while still participating in `object()`,
+ * `union()`, `intersection()`, and other compositional helpers.
+ */
+/**
+ * Return type produced by an `any` validator. Exposes the literal `"any"`
+ * tag through the `type` field so `ValidateType<"any">` can map it back to
+ * the `any` runtime type when consumed by downstream helpers.
+ */
+export interface AnyReturnType {
+    validate: boolean;
+    message: string;
+    type: "any";
+}
+/**
+ * Creates a validator that accepts any value
+ * @returns {Function} - Validator that always succeeds
+ */
+export declare const any: () => ((value: any) => AnyReturnType);

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

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.any = void 0;
+/**
+ * Any validation core module
+ * Provides a validator that accepts any value, useful when a position in a
+ * schema needs to remain wide open while still participating in `object()`,
+ * `union()`, `intersection()`, and other compositional helpers.
+ */
+
+/**
+ * Return type produced by an `any` validator. Exposes the literal `"any"`
+ * tag through the `type` field so `ValidateType<"any">` can map it back to
+ * the `any` runtime type when consumed by downstream helpers.
+ */
+
+// biome-ignore lint/suspicious/noExplicitAny: signature mirrors the return type
+var anyValidator = function anyValidator(_value) {
+  return {
+    validate: true,
+    message: "",
+    type: "any"
+  };
+};
+
+/**
+ * Creates a validator that accepts any value
+ * @returns {Function} - Validator that always succeeds
+ */
+// biome-ignore lint/suspicious/noExplicitAny: any() must accept and infer any value
+var any = exports.any = function any() {
+  return anyValidator;
+};

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

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

package/module/es5/Validate/any/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/array/arrayOf.d.ts

@@ -1,9 +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
- * @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>(validator: (value: T) => ValidateCoreReturnType<T>, message?: string) => (values: T[]) => ValidateCoreReturnType<T[]>;
+export declare const arrayOf: <V extends (value: never) => {
+    type: unknown;
+    message: string;
+    validate: boolean;
+}>(validator: V, message?: string) => (values: ExtractValidatedType<V>[]) => ValidateCoreReturnType<ExtractValidatedType<V>[]>;
+export {};

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

@@ -8,10 +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
- * @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
  */
@@ -28,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/bigint/core.d.ts

@@ -0,0 +1,24 @@
+/**
+ * BigInt validation core module
+ * Provides the base validation functionality for bigint values
+ */
+import type { ValidateReturnType } from "../../Validate/type";
+/**
+ * Return type produced by a `bigint` validator. Structurally compatible with
+ * `ValidateCoreReturnType<bigint>`, but exposes the literal `"bigint"` tag
+ * through the `type` field so `ValidateType<"bigint">` can map it back to the
+ * `bigint` runtime type when consumed by `object()`, `union()`, and friends.
+ */
+export interface BigIntReturnType {
+    validate: boolean;
+    message: string;
+    type: "bigint";
+}
+/**
+ * Creates a bigint validator with optional validation rules
+ * @template T - Array of validation rules for bigints
+ * @param {T} [option] - Array of validation functions to apply
+ * @param {string} [message] - Custom error message for type validation
+ * @returns {Function} - Validator function that checks if the value is a bigint and applies validation rules
+ */
+export declare const bigint: <T extends ValidateReturnType<bigint>[]>(option?: T, message?: string) => (value: bigint) => BigIntReturnType;

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

@@ -0,0 +1,65 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.bigint = 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; }
+/**
+ * BigInt validation core module
+ * Provides the base validation functionality for bigint values
+ */
+
+/**
+ * Return type produced by a `bigint` validator. Structurally compatible with
+ * `ValidateCoreReturnType<bigint>`, but exposes the literal `"bigint"` tag
+ * through the `type` field so `ValidateType<"bigint">` can map it back to the
+ * `bigint` runtime type when consumed by `object()`, `union()`, and friends.
+ */
+
+/**
+ * Creates a bigint validator with optional validation rules
+ * @template T - Array of validation rules for bigints
+ * @param {T} [option] - Array of validation functions to apply
+ * @param {string} [message] - Custom error message for type validation
+ * @returns {Function} - Validator function that checks if the value is a bigint and applies validation rules
+ */
+var bigint = exports.bigint = function bigint() {
+  var option = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  var message = arguments.length > 1 ? arguments[1] : undefined;
+  return function (value) {
+    if (typeof value !== "bigint") {
+      return {
+        validate: false,
+        message: message !== null && message !== void 0 ? message : "",
+        type: "bigint"
+      };
+    }
+    var _iterator = _createForOfIteratorHelper(option),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var rule = _step.value;
+        if (!rule.validate(value)) {
+          var _rule$message;
+          return {
+            validate: false,
+            message: (_rule$message = rule.message) !== null && _rule$message !== void 0 ? _rule$message : "",
+            type: "bigint"
+          };
+        }
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+    return {
+      validate: true,
+      message: "",
+      type: "bigint"
+    };
+  };
+};

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

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