@azure-net/node-kit 0.0.0-stage → 0.1.1

package/dist/validation/rules/ValueRules.d.ts

@@ -0,0 +1,82 @@
+import { Blob, File } from "node:buffer";
+import type { RuleOptions } from "../Types.js";
+type Literal = string | number | bigint | boolean | null;
+type Numeric = number | bigint;
+type Comparable = Numeric | Date;
+type EnumValue<T> = T extends readonly (infer V)[] ? V : T[keyof T];
+export interface ValueRangeOptions extends RuleOptions {
+    readonly inclusive?: boolean;
+    readonly minInclusive?: boolean;
+    readonly maxInclusive?: boolean;
+}
+export interface ValueClockOptions extends RuleOptions {
+    /** Evaluated for each validation, not when constructing the rule. */
+    readonly clock?: () => Date | number;
+}
+export interface ValueFileOptions extends RuleOptions {
+    readonly minSize?: number;
+    readonly maxSize?: number;
+    /** Matches Blob.type's type/subtype, ignoring parameters (e.g. charset). Metadata only, not byte verification. */
+    readonly mimeTypes?: readonly string[];
+    /** Case-insensitive suffixes, with or without a leading dot. */
+    readonly extensions?: readonly string[];
+}
+export declare const valueRules: Readonly<{
+    number: (options?: RuleOptions) => import("../Types.js").BuiltinRule<number, unknown, unknown>;
+    finite: (options?: RuleOptions) => import("../Types.js").BuiltinRule<number, unknown, unknown>;
+    bigint: (options?: RuleOptions) => import("../Types.js").BuiltinRule<bigint, unknown, unknown>;
+    boolean: (options?: RuleOptions) => import("../Types.js").BuiltinRule<boolean, unknown, unknown>;
+    date: (options?: RuleOptions) => import("../Types.js").BuiltinRule<Date, unknown, unknown>;
+    symbol: (options?: RuleOptions) => import("../Types.js").BuiltinRule<symbol, unknown, unknown>;
+    literal<const T extends Literal>(expected: T, options?: RuleOptions): import("../Types.js").BuiltinRule<T, unknown, unknown>;
+    enum<const T extends readonly Literal[] | Readonly<Record<string, string | number>>>(enumeration: T, options?: RuleOptions): import("../Types.js").BuiltinRule<EnumValue<T>, unknown, unknown>;
+    enumName<const T extends Readonly<Record<string, string | number>>>(enumeration: T, options?: RuleOptions): import("../Types.js").BuiltinRule<Extract<keyof T, string>, unknown, unknown>;
+    integer: (options?: RuleOptions) => import("../Types.js").BuiltinRule<never, unknown, unknown>;
+    int32: (options?: RuleOptions) => import("../Types.js").BuiltinRule<number, unknown, unknown>;
+    uint32: (options?: RuleOptions) => import("../Types.js").BuiltinRule<number, unknown, unknown>;
+    /** Like Zod's float32: finite range only, not exact Math.fround representability; no rounding. */
+    float32: (options?: RuleOptions) => import("../Types.js").BuiltinRule<number, unknown, unknown>;
+    /** 64-bit formats require bigint: JS numbers cannot represent their full ranges safely. */
+    int64: (options?: RuleOptions) => import("../Types.js").BuiltinRule<bigint, unknown, unknown>;
+    uint64: (options?: RuleOptions) => import("../Types.js").BuiltinRule<bigint, unknown, unknown>;
+    safeInteger: (options?: RuleOptions) => import("../Types.js").BuiltinRule<never, unknown, unknown>;
+    positive: (options?: RuleOptions) => import("../Types.js").BuiltinRule<never, unknown, unknown>;
+    negative: (options?: RuleOptions) => import("../Types.js").BuiltinRule<never, unknown, unknown>;
+    nonNegative: (options?: RuleOptions) => import("../Types.js").BuiltinRule<never, unknown, unknown>;
+    nonPositive: (options?: RuleOptions) => import("../Types.js").BuiltinRule<never, unknown, unknown>;
+    min(min: Comparable, options?: ValueRangeOptions): import("../Types.js").BuiltinRule<never, unknown, unknown>;
+    max(max: Comparable, options?: ValueRangeOptions): import("../Types.js").BuiltinRule<never, unknown, unknown>;
+    lessThan(max: Comparable, options?: ValueRangeOptions): import("../Types.js").BuiltinRule<never, unknown, unknown>;
+    greaterThan(min: Comparable, options?: ValueRangeOptions): import("../Types.js").BuiltinRule<never, unknown, unknown>;
+    lessThanOrEqual: (max: Comparable, options?: RuleOptions) => import("../Types.js").BuiltinRule<never, unknown, unknown>;
+    greaterThanOrEqual: (min: Comparable, options?: RuleOptions) => import("../Types.js").BuiltinRule<never, unknown, unknown>;
+    between(min: Comparable, max: Comparable, options?: ValueRangeOptions): import("../Types.js").BuiltinRule<never, unknown, unknown>;
+    multipleOf(divisor: Numeric, options?: RuleOptions): import("../Types.js").BuiltinRule<never, unknown, unknown>;
+    /** Decimal notation up to 4096 characters; optionally limit fractional places after exponent expansion. */
+    decimal(places?: number, options?: RuleOptions): import("../Types.js").BuiltinRule<never, unknown, unknown>;
+    /** SQL-style precision/scale: at most precision-scale integer and scale fractional digits; 4096-character input limit. */
+    precisionScale(precision: number, scale: number, options?: RuleOptions): import("../Types.js").BuiltinRule<never, unknown, unknown>;
+    /** Equality uses Node's isDeepStrictEqual, including Object.is semantics for primitives. */
+    equal: (expected: unknown, options?: RuleOptions) => import("../Types.js").BuiltinRule<never, unknown, unknown>;
+    notEqual: (expected: unknown, options?: RuleOptions) => import("../Types.js").BuiltinRule<never, unknown, unknown>;
+    notNull: (options?: RuleOptions) => import("../Types.js").BuiltinRule<never, unknown, unknown>;
+    required: (options?: RuleOptions) => import("../Types.js").BuiltinRule<never, unknown, unknown>;
+    notEmpty: (options?: RuleOptions) => import("../Types.js").BuiltinRule<never, unknown, unknown>;
+    empty: (options?: RuleOptions) => import("../Types.js").BuiltinRule<never, unknown, unknown>;
+    unknown: (options?: RuleOptions) => import("../Types.js").BuiltinRule<unknown, unknown, unknown>;
+    never: (options?: RuleOptions) => import("../Types.js").BuiltinRule<never, unknown, unknown>;
+    null: (options?: RuleOptions) => import("../Types.js").BuiltinRule<null, unknown, unknown>;
+    undefined: (options?: RuleOptions) => import("../Types.js").BuiltinRule<undefined, unknown, unknown>;
+    nan: (options?: RuleOptions) => import("../Types.js").BuiltinRule<number, unknown, unknown>;
+    instanceOf<T>(constructor: abstract new (...args: any[]) => T, options?: RuleOptions): import("../Types.js").BuiltinRule<T, unknown, unknown>;
+    /** Real File instances only; metadata validation never reads or verifies content bytes. */
+    file: (options?: ValueFileOptions) => import("../Types.js").BuiltinRule<File, unknown, unknown>;
+    /** Blob or File instances; extension constraints require a real File name. Metadata only. */
+    blob: (options?: ValueFileOptions) => import("../Types.js").BuiltinRule<Blob, unknown, unknown>;
+    before: (target: Date, options?: RuleOptions) => import("../Types.js").BuiltinRule<never, unknown, unknown>;
+    after: (target: Date, options?: RuleOptions) => import("../Types.js").BuiltinRule<never, unknown, unknown>;
+    same: (target: Date, options?: RuleOptions) => import("../Types.js").BuiltinRule<never, unknown, unknown>;
+    isPast: (options?: ValueClockOptions) => import("../Types.js").BuiltinRule<never, unknown, unknown>;
+    isFuture: (options?: ValueClockOptions) => import("../Types.js").BuiltinRule<never, unknown, unknown>;
+}>;
+export {};

package/dist/validation/rules/ValueRules.js

@@ -0,0 +1,365 @@
+import { Blob, File } from "node:buffer";
+import { isDeepStrictEqual } from "node:util";
+import { sizeOption, testRule } from "./Factory.js";
+const finite = (value) => typeof value === "number" && Number.isFinite(value);
+const numeric = (value) => finite(value) || typeof value === "bigint";
+const dateTime = (value) => Date.prototype.getTime.call(value);
+const validDate = (value) => {
+    if (!(value instanceof Date))
+        return false;
+    try {
+        return Number.isFinite(dateTime(value));
+    }
+    catch {
+        return false;
+    }
+};
+const literalValue = (value) => value === null ||
+    typeof value === "string" ||
+    typeof value === "bigint" ||
+    typeof value === "boolean" ||
+    finite(value);
+function numericConfig(value) {
+    if (!numeric(value))
+        throw new TypeError("Expected a finite number or bigint.");
+}
+function inclusivity(options) {
+    for (const key of ["inclusive", "minInclusive", "maxInclusive"]) {
+        if (options[key] !== undefined && typeof options[key] !== "boolean")
+            throw new TypeError(`${key} must be boolean.`);
+    }
+}
+const MAX_DECIMAL_LENGTH = 4096;
+const blobSize = Object.getOwnPropertyDescriptor(Blob.prototype, "size").get;
+const fileName = Object.getOwnPropertyDescriptor(File.prototype, "name").get;
+const blobType = Object.getOwnPropertyDescriptor(Blob.prototype, "type").get;
+// Normalize decimal notation without floating-point arithmetic or exponent-sized allocations.
+// Numbers use their shortest round-trip decimal representation; strings preserve exact digits.
+function decimalParts(value) {
+    if (typeof value !== "string" && !finite(value))
+        return undefined;
+    const text = String(value);
+    if (text.length > MAX_DECIMAL_LENGTH)
+        return undefined;
+    const match = /^([+-]?)(?:(\d+)(?:\.(\d*))?|\.(\d+))(?:[eE]([+-]?\d+))?$/.exec(text);
+    if (!match || match[0] !== text)
+        return undefined;
+    const fraction = match[3] ?? match[4] ?? "";
+    let digits = ((match[2] ?? "") + fraction).replace(/^0+/, "");
+    if (!digits)
+        return { digits: "0", power: 0n };
+    let end = digits.length;
+    while (digits[end - 1] === "0")
+        end--;
+    const exponent = match[5] ?? "0";
+    const negative = exponent[0] === "-";
+    const significant = exponent.replace(/^[+-]?0*/, "");
+    // Saturation is exact for our comparisons: even after digit offsets, these exponents
+    // exceed every permitted safe-integer precision/scale. Never parse an unbounded BigInt.
+    const magnitude = significant.length > 16
+        ? BigInt(Number.MAX_SAFE_INTEGER) + BigInt(MAX_DECIMAL_LENGTH) + 1n
+        : BigInt(significant || "0");
+    const power = (negative ? -magnitude : magnitude) -
+        BigInt(fraction.length) +
+        BigInt(digits.length - end);
+    digits = digits.slice(0, end);
+    return { digits, power };
+}
+function exactMultiple(value, divisor) {
+    const a = decimalParts(value);
+    const b = decimalParts(divisor);
+    if (a.digits === "0")
+        return true;
+    const difference = a.power - b.power;
+    // Finite binary64 decimal powers range from -324 through 308. Enforce this bound
+    // before exponentiation, even if this helper's callers change in the future.
+    if (difference < -632n || difference > 632n)
+        return false;
+    return difference >= 0n
+        ? (BigInt(a.digits) * 10n ** difference) % BigInt(b.digits) === 0n
+        : BigInt(a.digits) % (BigInt(b.digits) * 10n ** -difference) === 0n;
+}
+function comparisonBound(bound) {
+    if (validDate(bound))
+        return { kind: "date", value: dateTime(bound) };
+    numericConfig(bound);
+    return { kind: typeof bound, value: bound };
+}
+function comparableValue(value, kind) {
+    if (kind === "date")
+        return validDate(value) ? dateTime(value) : undefined;
+    return typeof value === kind && numeric(value) ? value : undefined;
+}
+function comparisonRule(code, bound, greater, inclusive, options) {
+    const target = comparisonBound(bound);
+    return testRule(code, (value) => {
+        const actual = comparableValue(value, target.kind);
+        return (actual !== undefined &&
+            (greater
+                ? inclusive
+                    ? actual >= target.value
+                    : actual > target.value
+                : inclusive
+                    ? actual <= target.value
+                    : actual < target.value));
+    }, options, { [greater ? "min" : "max"]: target.value, inclusive });
+}
+function enumEntries(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        throw new TypeError("Expected an enum object.");
+    const entries = Object.entries(value);
+    if (!entries.length ||
+        entries.some(([, item]) => typeof item !== "string" && !finite(item)))
+        throw new TypeError("Enum values must be strings or finite numbers.");
+    return entries.filter(([key, item]) => !(typeof item === "string" &&
+        Object.hasOwn(value, item) &&
+        typeof value[item] === "number" &&
+        String(value[item]) === key));
+}
+function emptyValue(value) {
+    return (value === null ||
+        value === undefined ||
+        (typeof value === "string" && value.trim() === "") ||
+        (Array.isArray(value) && value.length === 0) ||
+        ((value instanceof Map || value instanceof Set) && value.size === 0) ||
+        (value instanceof Blob && value.size === 0) ||
+        (value !== null &&
+            typeof value === "object" &&
+            (Object.getPrototypeOf(value) === Object.prototype ||
+                Object.getPrototypeOf(value) === null) &&
+            Reflect.ownKeys(value).length === 0));
+}
+function dateComparison(code, target, compare, options) {
+    if (!validDate(target))
+        throw new TypeError("Expected a valid Date.");
+    const timestamp = dateTime(target);
+    return testRule(code, (value) => validDate(value) && compare(dateTime(value), timestamp), options, { timestamp });
+}
+function relativeDate(code, future, options) {
+    if (options.clock !== undefined && typeof options.clock !== "function")
+        throw new TypeError("clock must be a function.");
+    const clock = options.clock ?? (() => Date.now());
+    return testRule(code, (value) => {
+        if (!validDate(value))
+            return false;
+        const now = clock();
+        const timestamp = validDate(now) ? dateTime(now) : now;
+        if (!finite(timestamp))
+            throw new TypeError("clock must return a finite timestamp or valid Date.");
+        return future ? dateTime(value) > timestamp : dateTime(value) < timestamp;
+    }, options);
+}
+function binaryRule(code, options) {
+    const { minSize, maxSize } = options;
+    if (minSize !== undefined)
+        sizeOption(minSize, "minSize");
+    if (maxSize !== undefined)
+        sizeOption(maxSize, "maxSize");
+    if (minSize !== undefined && maxSize !== undefined && minSize > maxSize)
+        throw new RangeError("minSize must not exceed maxSize.");
+    for (const key of ["mimeTypes", "extensions"]) {
+        const list = options[key];
+        if (list !== undefined &&
+            (!Array.isArray(list) ||
+                Array.from(list).some((item) => typeof item !== "string" || !item || item.trim() !== item)))
+            throw new TypeError(`${key} must be an array of non-empty, unpadded strings.`);
+    }
+    const mimeTypes = options.mimeTypes &&
+        Object.freeze(options.mimeTypes.map((item) => item.toLowerCase()));
+    if (mimeTypes?.some((item) => !/^[\w!#$&^.+-]+\/(?:[\w!#$&^.+-]+|\*)$/.test(item)))
+        throw new TypeError("Invalid MIME type.");
+    const extensions = options.extensions &&
+        Object.freeze(options.extensions.map((item) => item.replace(/^\./, "").toLowerCase()));
+    if (extensions?.some((item) => !/^[a-z0-9_-]+(?:\.[a-z0-9_-]+)*$/.test(item)))
+        throw new TypeError("Invalid extension.");
+    return testRule(code, (value) => {
+        if (!(value instanceof Blob))
+            return false;
+        let size;
+        let mime;
+        let name;
+        try {
+            size = blobSize.call(value);
+            mime = blobType.call(value);
+            if (code === "file" || extensions) {
+                if (!(value instanceof File))
+                    return false;
+                name = fileName.call(value);
+                if (typeof name !== "string")
+                    return false;
+            }
+        }
+        catch {
+            return false;
+        }
+        if ((minSize !== undefined && size < minSize) ||
+            (maxSize !== undefined && size > maxSize))
+            return false;
+        if (mimeTypes) {
+            // Bun may add charset metadata where Node does not. Compare the MIME essence,
+            // not its parameters, while still rejecting malformed types before wildcard matching.
+            const essence = mime.split(";", 1)[0].trim().toLowerCase();
+            if (!/^[\w!#$&^.+-]+\/[\w!#$&^.+-]+$/.test(essence) ||
+                !mimeTypes.some((type) => type.endsWith("/*")
+                    ? essence.startsWith(type.slice(0, -1))
+                    : essence === type))
+                return false;
+        }
+        if (extensions) {
+            if (!extensions.some((extension) => name.toLowerCase().endsWith(`.${extension}`)))
+                return false;
+        }
+        return true;
+    }, options, { minSize, maxSize, mimeTypes, extensions }, true);
+}
+export const valueRules = Object.freeze({
+    number: (options = {}) => testRule("number", finite, options, {}, true),
+    finite: (options = {}) => testRule("finite", finite, options, {}, true),
+    bigint: (options = {}) => testRule("bigint", (value) => typeof value === "bigint", options, {}, true),
+    boolean: (options = {}) => testRule("boolean", (value) => typeof value === "boolean", options, {}, true),
+    date: (options = {}) => testRule("date", validDate, options, {}, true),
+    symbol: (options = {}) => testRule("symbol", (value) => typeof value === "symbol", options, {}, true),
+    literal(expected, options = {}) {
+        if (!literalValue(expected))
+            throw new TypeError("Expected a string, finite number, bigint, boolean or null literal.");
+        return testRule("literal", (value) => Object.is(value, expected), options, { expected }, true);
+    },
+    enum(enumeration, options = {}) {
+        let allowed;
+        if (Array.isArray(enumeration)) {
+            allowed = Array.from(enumeration);
+            if (!allowed.length || !allowed.every(literalValue))
+                throw new TypeError("Enum members must be strings, finite numbers, bigints, booleans or null.");
+        }
+        else {
+            allowed = enumEntries(enumeration).map(([, value]) => value);
+        }
+        const values = Object.freeze(allowed);
+        return testRule("enum", (value) => values.some((item) => Object.is(item, value)), options, { values }, true);
+    },
+    enumName(enumeration, options = {}) {
+        const names = Object.freeze(enumEntries(enumeration).map(([name]) => name));
+        return testRule("enumName", (value) => typeof value === "string" && names.includes(value), options, { names }, true);
+    },
+    integer: (options = {}) => testRule("integer", (value) => typeof value === "bigint" || (finite(value) && Number.isInteger(value)), options),
+    int32: (options = {}) => testRule("int32", (value) => finite(value) &&
+        Number.isSafeInteger(value) &&
+        value >= -2147483648 &&
+        value <= 2147483647, options, {}, true),
+    uint32: (options = {}) => testRule("uint32", (value) => finite(value) &&
+        Number.isSafeInteger(value) &&
+        value >= 0 &&
+        value <= 4294967295, options, {}, true),
+    /** Like Zod's float32: finite range only, not exact Math.fround representability; no rounding. */
+    float32: (options = {}) => testRule("float32", (value) => finite(value) && Math.abs(value) <= 3.4028234663852886e38, options, {}, true),
+    /** 64-bit formats require bigint: JS numbers cannot represent their full ranges safely. */
+    int64: (options = {}) => testRule("int64", (value) => typeof value === "bigint" &&
+        value >= -9223372036854775808n &&
+        value <= 9223372036854775807n, options, {}, true),
+    uint64: (options = {}) => testRule("uint64", (value) => typeof value === "bigint" &&
+        value >= 0n &&
+        value <= 18446744073709551615n, options, {}, true),
+    safeInteger: (options = {}) => testRule("safeInteger", (value) => typeof value === "bigint"
+        ? value >= BigInt(Number.MIN_SAFE_INTEGER) &&
+            value <= BigInt(Number.MAX_SAFE_INTEGER)
+        : finite(value) && Number.isSafeInteger(value), options),
+    positive: (options = {}) => testRule("positive", (value) => numeric(value) && value > 0, options),
+    negative: (options = {}) => testRule("negative", (value) => numeric(value) && value < 0, options),
+    nonNegative: (options = {}) => testRule("nonNegative", (value) => numeric(value) && value >= 0, options),
+    nonPositive: (options = {}) => testRule("nonPositive", (value) => numeric(value) && value <= 0, options),
+    min(min, options = {}) {
+        inclusivity(options);
+        return comparisonRule("min", min, true, options.inclusive !== false, options);
+    },
+    max(max, options = {}) {
+        inclusivity(options);
+        return comparisonRule("max", max, false, options.inclusive !== false, options);
+    },
+    lessThan(max, options = {}) {
+        inclusivity(options);
+        return comparisonRule("lessThan", max, false, options.inclusive ?? false, options);
+    },
+    greaterThan(min, options = {}) {
+        inclusivity(options);
+        return comparisonRule("greaterThan", min, true, options.inclusive ?? false, options);
+    },
+    lessThanOrEqual: (max, options = {}) => comparisonRule("lessThanOrEqual", max, false, true, options),
+    greaterThanOrEqual: (min, options = {}) => comparisonRule("greaterThanOrEqual", min, true, true, options),
+    between(min, max, options = {}) {
+        const lower = comparisonBound(min);
+        const upper = comparisonBound(max);
+        inclusivity(options);
+        if (lower.kind !== upper.kind || lower.value > upper.value)
+            throw new RangeError("Bounds must have the same type and min must not exceed max.");
+        const minInclusive = options.minInclusive ?? options.inclusive ?? true;
+        const maxInclusive = options.maxInclusive ?? options.inclusive ?? true;
+        return testRule("between", (value) => {
+            const actual = comparableValue(value, lower.kind);
+            return (actual !== undefined &&
+                (minInclusive ? actual >= lower.value : actual > lower.value) &&
+                (maxInclusive ? actual <= upper.value : actual < upper.value));
+        }, options, { min: lower.value, max: upper.value, minInclusive, maxInclusive });
+    },
+    multipleOf(divisor, options = {}) {
+        numericConfig(divisor);
+        if (divisor === 0 || divisor === 0n)
+            throw new RangeError("divisor must not be zero.");
+        return testRule("multipleOf", (value) => typeof divisor === "bigint"
+            ? typeof value === "bigint" && value % divisor === 0n
+            : finite(value) && exactMultiple(value, divisor), options, { divisor });
+    },
+    /** Decimal notation up to 4096 characters; optionally limit fractional places after exponent expansion. */
+    decimal(places, options = {}) {
+        if (places !== undefined)
+            sizeOption(places, "places");
+        return testRule("decimal", (value) => {
+            const parts = decimalParts(value);
+            return (parts !== undefined &&
+                (places === undefined || parts.power >= -BigInt(places)));
+        }, options, places === undefined ? {} : { places });
+    },
+    /** SQL-style precision/scale: at most precision-scale integer and scale fractional digits; 4096-character input limit. */
+    precisionScale(precision, scale, options = {}) {
+        sizeOption(precision, "precision");
+        sizeOption(scale, "scale");
+        if (precision === 0 || scale > precision)
+            throw new RangeError("Require precision > 0 and scale <= precision.");
+        return testRule("precisionScale", (value) => {
+            const parts = decimalParts(value);
+            if (!parts)
+                return false;
+            if (parts.digits === "0")
+                return true;
+            return (parts.power >= -BigInt(scale) &&
+                BigInt(parts.digits.length) + parts.power <= BigInt(precision - scale));
+        }, options, { precision, scale });
+    },
+    /** Equality uses Node's isDeepStrictEqual, including Object.is semantics for primitives. */
+    equal: (expected, options = {}) => testRule("equal", (value) => isDeepStrictEqual(value, expected), options, {
+        expected,
+    }),
+    notEqual: (expected, options = {}) => testRule("notEqual", (value) => !isDeepStrictEqual(value, expected), options, { expected }),
+    notNull: (options = {}) => testRule("notNull", (value) => value !== null, options),
+    required: (options = {}) => testRule("required", (value) => value !== null && value !== undefined, options),
+    notEmpty: (options = {}) => testRule("notEmpty", (value) => !emptyValue(value), options),
+    empty: (options = {}) => testRule("empty", emptyValue, options),
+    unknown: (options = {}) => testRule("unknown", () => true, options, {}, true),
+    never: (options = {}) => testRule("never", () => false, options, {}, true),
+    null: (options = {}) => testRule("null", (value) => value === null, options, {}, true),
+    undefined: (options = {}) => testRule("undefined", (value) => value === undefined, options, {}, true),
+    nan: (options = {}) => testRule("nan", (value) => typeof value === "number" && Number.isNaN(value), options, {}, true),
+    instanceOf(constructor, options = {}) {
+        if (typeof constructor !== "function" || !constructor.prototype)
+            throw new TypeError("Expected a constructor.");
+        return testRule("instanceOf", (value) => value instanceof constructor, options, { name: constructor.name }, true);
+    },
+    /** Real File instances only; metadata validation never reads or verifies content bytes. */
+    file: (options = {}) => binaryRule("file", options),
+    /** Blob or File instances; extension constraints require a real File name. Metadata only. */
+    blob: (options = {}) => binaryRule("blob", options),
+    before: (target, options = {}) => dateComparison("before", target, (a, b) => a < b, options),
+    after: (target, options = {}) => dateComparison("after", target, (a, b) => a > b, options),
+    same: (target, options = {}) => dateComparison("same", target, (a, b) => a === b, options),
+    isPast: (options = {}) => relativeDate("isPast", false, options),
+    isFuture: (options = {}) => relativeDate("isFuture", true, options),
+});

package/dist/validation/rules/index.d.ts

@@ -0,0 +1,151 @@
+import type { RuleOptions, BuiltinRule, FieldRule, ValidationRules } from "../Types.js";
+import { validatorDefinition } from "../Symbols.js";
+export type { LengthOptions, UuidOptions, UrlOptions, NanoidOptions, JwtOptions, MacOptions, HashOptions, IsoTimeOptions, IsoDateTimeOptions, HashAlgorithm, } from "./StringRules.js";
+export type { ValueRangeOptions, ValueClockOptions, ValueFileOptions, } from "./ValueRules.js";
+export declare const rules: Readonly<{
+    when<T, D = unknown, R = D, C = unknown>(condition: (context: import("../Types.js").RuleContext<T, D, R, C>) => boolean, checks: readonly FieldRule<T, D, R, C>[]): import("../Types.js").ValidationRule<T, D, R, C>;
+    contains(expected: unknown, options?: RuleOptions): BuiltinRule<never>;
+    some<T>(predicate: (value: T, index: number) => boolean, options?: RuleOptions): import("../Types.js").ValidationRule<T[]>;
+    every<T>(predicate: (value: T, index: number) => boolean, options?: RuleOptions): import("../Types.js").ValidationRule<T[]>;
+    optional: () => BuiltinRule<undefined>;
+    nullable: () => BuiltinRule<null>;
+    nullish: () => BuiltinRule<null | undefined>;
+    object<T extends object, TRoot = unknown, C = unknown>(shape: ValidationRules<T, TRoot, C>, options?: RuleOptions & {
+        unknownKeys?: "reject" | "allow";
+    }): BuiltinRule<T, C, TRoot>;
+    array<T, TRoot = unknown, C = unknown>(items: readonly FieldRule<T, T[], TRoot, C>[], options?: RuleOptions): BuiltinRule<T[], C, TRoot>;
+    tuple<T extends readonly unknown[], TRoot = unknown, C = unknown>(items: { readonly [K in keyof T]: readonly FieldRule<T[K], T, TRoot, C>[]; }, options?: RuleOptions): BuiltinRule<T, C, TRoot>;
+    record<T, TRoot = unknown, C = unknown>(items: readonly FieldRule<T, Record<string, T>, TRoot, C>[], options?: RuleOptions, keys?: readonly FieldRule<string, Record<string, T>, TRoot, C>[]): BuiltinRule<Record<string, T>, C, TRoot>;
+    map<K, V, TRoot = unknown, C = unknown>(keys: readonly FieldRule<K, Map<K, V>, TRoot, C>[], items: readonly FieldRule<V, Map<K, V>, TRoot, C>[], options?: RuleOptions): BuiltinRule<Map<K, V>, C, TRoot>;
+    set<T, TRoot = unknown, C = unknown>(items: readonly FieldRule<T, Set<T>, TRoot, C>[], options?: RuleOptions): BuiltinRule<Set<T>, C, TRoot>;
+    union<T, D = unknown, TRoot = unknown, C = unknown>(alternatives: readonly (readonly FieldRule<T, D, TRoot, C>[])[], options?: RuleOptions): BuiltinRule<T, C, TRoot>;
+    discriminatedUnion<T, D = unknown, TRoot = unknown, C = unknown>(key: string, variants: Readonly<Record<string, readonly FieldRule<T, D, TRoot, C>[]>>, options?: RuleOptions): BuiltinRule<T, C, TRoot>;
+    intersection<A extends object, B extends object, TRoot = unknown, C = unknown>(left: ValidationRules<A, TRoot, C>, right: ValidationRules<B, TRoot, C>, options?: RuleOptions): BuiltinRule<A & B, C, TRoot>;
+    validator<T extends object, C>(validator: (new () => import("../Validator.js").Validator<T, C>) & {
+        [validatorDefinition](): Readonly<Record<string, readonly import("../Types.js").AnyRule[]>>;
+        readonly configuration: {
+            readonly unknownKeys?: "reject" | "allow";
+        };
+    }, options?: RuleOptions): BuiltinRule<T, C>;
+    lazy<T, D = unknown, TRoot = unknown, C = unknown>(resolve: () => readonly FieldRule<T, D, TRoot, C>[], options?: RuleOptions): BuiltinRule<T, C, TRoot>;
+    unique(options?: RuleOptions): BuiltinRule<never>;
+    uniqueBy<T>(key: keyof T, options?: RuleOptions): BuiltinRule<never>;
+    sameAs(key: string, options?: RuleOptions): BuiltinRule<never>;
+    notSameAs(key: string, options?: RuleOptions): BuiltinRule<never>;
+    string(options?: RuleOptions): BuiltinRule<string>;
+    length(length: number, options?: import("./StringRules.js").LengthOptions): BuiltinRule<never>;
+    minLength(minLength: number, options?: import("./StringRules.js").LengthOptions): BuiltinRule<never>;
+    maxLength(maxLength: number, options?: import("./StringRules.js").LengthOptions): BuiltinRule<never>;
+    matches(regex: RegExp, options?: RuleOptions): BuiltinRule<string>;
+    includes(substring: string, options?: RuleOptions): BuiltinRule<string>;
+    startsWith(prefix: string, options?: RuleOptions): BuiltinRule<string>;
+    endsWith(suffix: string, options?: RuleOptions): BuiltinRule<string>;
+    lowercase(options?: RuleOptions): BuiltinRule<string>;
+    uppercase(options?: RuleOptions): BuiltinRule<string>;
+    email(options?: RuleOptions): BuiltinRule<string>;
+    uuid(options?: import("./StringRules.js").UuidOptions): BuiltinRule<string>;
+    guid(options?: RuleOptions): BuiltinRule<string>;
+    url(options?: import("./StringRules.js").UrlOptions): BuiltinRule<string>;
+    httpUrl(options?: import("./StringRules.js").UrlOptions): BuiltinRule<string>;
+    hostname(options?: RuleOptions): BuiltinRule<string>;
+    e164(options?: RuleOptions): BuiltinRule<string>;
+    emoji(options?: RuleOptions): BuiltinRule<string>;
+    base64(options?: RuleOptions): BuiltinRule<string>;
+    base64url(options?: RuleOptions): BuiltinRule<string>;
+    hex(options?: RuleOptions): BuiltinRule<string>;
+    jwt(options?: import("./StringRules.js").JwtOptions): BuiltinRule<string>;
+    nanoid(options?: import("./StringRules.js").NanoidOptions): BuiltinRule<string>;
+    cuid(options?: RuleOptions): BuiltinRule<string>;
+    cuid2(options?: RuleOptions): BuiltinRule<string>;
+    ulid(options?: RuleOptions): BuiltinRule<string>;
+    xid(options?: RuleOptions): BuiltinRule<string>;
+    ksuid(options?: RuleOptions): BuiltinRule<string>;
+    ip(options?: RuleOptions): BuiltinRule<string>;
+    ipv4(options?: RuleOptions): BuiltinRule<string>;
+    ipv6(options?: RuleOptions): BuiltinRule<string>;
+    cidr(options?: RuleOptions): BuiltinRule<string>;
+    cidrv4(options?: RuleOptions): BuiltinRule<string>;
+    cidrv6(options?: RuleOptions): BuiltinRule<string>;
+    mac(options?: import("./StringRules.js").MacOptions): BuiltinRule<string>;
+    creditCard(options?: RuleOptions): BuiltinRule<string>;
+    iban(options?: RuleOptions): BuiltinRule<string>;
+    currencyCode(options?: RuleOptions): BuiltinRule<string>;
+    hash(algorithm: import("./StringRules.js").HashAlgorithm, options?: import("./StringRules.js").HashOptions): BuiltinRule<string>;
+    isoDate(options?: RuleOptions): BuiltinRule<string>;
+    isoTime(options?: import("./StringRules.js").IsoTimeOptions): BuiltinRule<string>;
+    isoDateTime(options?: import("./StringRules.js").IsoDateTimeOptions): BuiltinRule<string>;
+    isoDuration(options?: RuleOptions): BuiltinRule<string>;
+    number: (options?: RuleOptions) => BuiltinRule<number, unknown, unknown>;
+    finite: (options?: RuleOptions) => BuiltinRule<number, unknown, unknown>;
+    bigint: (options?: RuleOptions) => BuiltinRule<bigint, unknown, unknown>;
+    boolean: (options?: RuleOptions) => BuiltinRule<boolean, unknown, unknown>;
+    date: (options?: RuleOptions) => BuiltinRule<Date, unknown, unknown>;
+    symbol: (options?: RuleOptions) => BuiltinRule<symbol, unknown, unknown>;
+    literal: <const T extends string | number | bigint | boolean | null>(expected: T, options?: RuleOptions) => BuiltinRule<T, unknown, unknown>;
+    enum: <const T extends readonly (string | number | bigint | boolean | null)[] | Readonly<Record<string, string | number>>>(enumeration: T, options?: RuleOptions) => BuiltinRule<T extends readonly (infer V)[] ? V : T[keyof T], unknown, unknown>;
+    enumName: <const T extends Readonly<Record<string, string | number>>>(enumeration: T, options?: RuleOptions) => BuiltinRule<Extract<keyof T, string>, unknown, unknown>;
+    integer: (options?: RuleOptions) => BuiltinRule<never, unknown, unknown>;
+    int32: (options?: RuleOptions) => BuiltinRule<number, unknown, unknown>;
+    uint32: (options?: RuleOptions) => BuiltinRule<number, unknown, unknown>;
+    float32: (options?: RuleOptions) => BuiltinRule<number, unknown, unknown>;
+    int64: (options?: RuleOptions) => BuiltinRule<bigint, unknown, unknown>;
+    uint64: (options?: RuleOptions) => BuiltinRule<bigint, unknown, unknown>;
+    safeInteger: (options?: RuleOptions) => BuiltinRule<never, unknown, unknown>;
+    positive: (options?: RuleOptions) => BuiltinRule<never, unknown, unknown>;
+    negative: (options?: RuleOptions) => BuiltinRule<never, unknown, unknown>;
+    nonNegative: (options?: RuleOptions) => BuiltinRule<never, unknown, unknown>;
+    nonPositive: (options?: RuleOptions) => BuiltinRule<never, unknown, unknown>;
+    min: (min: Date | (number | bigint), options?: import("./ValueRules.js").ValueRangeOptions) => BuiltinRule<never, unknown, unknown>;
+    max: (max: Date | (number | bigint), options?: import("./ValueRules.js").ValueRangeOptions) => BuiltinRule<never, unknown, unknown>;
+    lessThan: (max: Date | (number | bigint), options?: import("./ValueRules.js").ValueRangeOptions) => BuiltinRule<never, unknown, unknown>;
+    greaterThan: (min: Date | (number | bigint), options?: import("./ValueRules.js").ValueRangeOptions) => BuiltinRule<never, unknown, unknown>;
+    lessThanOrEqual: (max: Date | (number | bigint), options?: RuleOptions) => BuiltinRule<never, unknown, unknown>;
+    greaterThanOrEqual: (min: Date | (number | bigint), options?: RuleOptions) => BuiltinRule<never, unknown, unknown>;
+    between: (min: Date | (number | bigint), max: Date | (number | bigint), options?: import("./ValueRules.js").ValueRangeOptions) => BuiltinRule<never, unknown, unknown>;
+    multipleOf: (divisor: number | bigint, options?: RuleOptions) => BuiltinRule<never, unknown, unknown>;
+    decimal: (places?: number, options?: RuleOptions) => BuiltinRule<never, unknown, unknown>;
+    precisionScale: (precision: number, scale: number, options?: RuleOptions) => BuiltinRule<never, unknown, unknown>;
+    equal: (expected: unknown, options?: RuleOptions) => BuiltinRule<never, unknown, unknown>;
+    notEqual: (expected: unknown, options?: RuleOptions) => BuiltinRule<never, unknown, unknown>;
+    notNull: (options?: RuleOptions) => BuiltinRule<never, unknown, unknown>;
+    required: (options?: RuleOptions) => BuiltinRule<never, unknown, unknown>;
+    notEmpty: (options?: RuleOptions) => BuiltinRule<never, unknown, unknown>;
+    empty: (options?: RuleOptions) => BuiltinRule<never, unknown, unknown>;
+    unknown: (options?: RuleOptions) => BuiltinRule<unknown, unknown, unknown>;
+    never: (options?: RuleOptions) => BuiltinRule<never, unknown, unknown>;
+    null: (options?: RuleOptions) => BuiltinRule<null, unknown, unknown>;
+    undefined: (options?: RuleOptions) => BuiltinRule<undefined, unknown, unknown>;
+    nan: (options?: RuleOptions) => BuiltinRule<number, unknown, unknown>;
+    instanceOf: <T>(constructor: abstract new (...args: any[]) => T, options?: RuleOptions) => BuiltinRule<T, unknown, unknown>;
+    file: (options?: import("./ValueRules.js").ValueFileOptions) => BuiltinRule<import("buffer").File, unknown, unknown>;
+    blob: (options?: import("./ValueRules.js").ValueFileOptions) => BuiltinRule<import("buffer").Blob, unknown, unknown>;
+    before: (target: Date, options?: RuleOptions) => BuiltinRule<never, unknown, unknown>;
+    after: (target: Date, options?: RuleOptions) => BuiltinRule<never, unknown, unknown>;
+    same: (target: Date, options?: RuleOptions) => BuiltinRule<never, unknown, unknown>;
+    isPast: (options?: import("./ValueRules.js").ValueClockOptions) => BuiltinRule<never, unknown, unknown>;
+    isFuture: (options?: import("./ValueRules.js").ValueClockOptions) => BuiltinRule<never, unknown, unknown>;
+}>;
+export type TypedRules<T extends object, C = unknown> = Omit<typeof rules, "sameAs" | "notSameAs" | "object" | "array" | "record" | "map" | "set" | "tuple"> & {
+    sameAs(key: keyof T & string, options?: RuleOptions): BuiltinRule<never>;
+    notSameAs(key: keyof T & string, options?: RuleOptions): BuiltinRule<never>;
+    object<V extends object>(shape: {
+        [K in keyof V]: K extends string | number ? readonly [
+            BuiltinRule<V[K], C, T>,
+            ...FieldRule<V[K], NoInfer<V>, T, C>[]
+        ] : never;
+    }, options?: RuleOptions & {
+        unknownKeys?: "reject" | "allow";
+    }): BuiltinRule<V, C, T>;
+    object<V extends object>(shape: ValidationRules<V, T, C>, options?: RuleOptions & {
+        unknownKeys?: "reject" | "allow";
+    }): BuiltinRule<V, C, T>;
+    array<V>(items: readonly FieldRule<V, V[], T, C>[], options?: RuleOptions): BuiltinRule<V[], C, T>;
+    record<V>(items: readonly FieldRule<V, Record<string, V>, T, C>[], options?: RuleOptions, keys?: readonly FieldRule<string, Record<string, V>, T, C>[]): BuiltinRule<Record<string, V>, C, T>;
+    map<K, V>(keys: readonly FieldRule<K, Map<K, V>, T, C>[], items: readonly FieldRule<V, Map<K, V>, T, C>[], options?: RuleOptions): BuiltinRule<Map<K, V>, C, T>;
+    set<V>(items: readonly FieldRule<V, Set<V>, T, C>[], options?: RuleOptions): BuiltinRule<Set<V>, C, T>;
+    tuple<V extends readonly unknown[]>(items: {
+        readonly [K in keyof V]: readonly FieldRule<V[K], V, T, C>[];
+    }, options?: RuleOptions): BuiltinRule<V, C, T>;
+};
+/** Binds root/context types for nested callbacks and sibling keys for comparisons. */
+export declare function createRules<T extends object, C = unknown>(): TypedRules<T, C>;

package/dist/validation/rules/index.js

@@ -0,0 +1,19 @@
+import { structureRules } from "./StructureRules.js";
+import { stringRules } from "./StringRules.js";
+import { valueRules } from "./ValueRules.js";
+import { customRules } from "./CustomRules.js";
+import { validatorDefinition } from "../Symbols.js";
+export const rules = Object.freeze({
+    ...valueRules,
+    ...stringRules,
+    ...structureRules,
+    ...customRules,
+});
+/** Binds root/context types for nested callbacks and sibling keys for comparisons. */
+export function createRules() {
+    return Object.freeze({
+        ...rules,
+        sameAs: (key, options) => structureRules.sameAs(key, options),
+        notSameAs: (key, options) => structureRules.notSameAs(key, options),
+    });
+}