@clementine-solutions/jane-io 1.0.0 → 1.0.2

package/dist/core/validators/date/is-past.js

@@ -0,0 +1,59 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Is Past
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Ensures the input is a Date instance representing a moment
+ *                  strictly before the current system time.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { validationEvent } from '../../pipeline';
+import { detectStructuralType } from '../../pipeline/scan';
+import { safeStringify } from '../../common';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Ensures the input is a Date instance representing a moment strictly
+ * before the current system time.
+ *
+ * - Non-Date values emit `date.not.date`.
+ * - Invalid Date instances emit `date.is.invalid`.
+ * - Dates ≥ now emit `date.in.future`.
+ *
+ * This rule is pure, total, async-compatible, and preserves the
+ * provided path. It supports userMessage overrides applied at the
+ * pipeline level.
+ */
+export const isPast = async (value, path) => {
+    const structuralType = detectStructuralType(value);
+    // ------------------------------------------------------------
+    // Type check — the input must be a Date instance.
+    // ------------------------------------------------------------
+    if (!(value instanceof Date)) {
+        return [
+            validationEvent('error', 'date.not.date', path, `Expected 'Date' but received '${structuralType}'.`, `Please provide a valid date.`, { value, expected: 'Date', actual: structuralType }),
+        ];
+    }
+    // ------------------------------------------------------------
+    // Validity check — reject invalid Date instances.
+    // ------------------------------------------------------------
+    if (isNaN(value.getTime())) {
+        return [
+            validationEvent('error', 'date.is.invalid', path, `Date value is invalid.`, `Please provide a valid date.`, { value, expected: 'valid Date', actual: value }),
+        ];
+    }
+    // ------------------------------------------------------------
+    // Past check — must be strictly less than now.
+    // ------------------------------------------------------------
+    if (value.getTime() >= Date.now()) {
+        return [
+            validationEvent('error', 'date.in.future', path, `${safeStringify(value)} must be in the past.`, `Please provide a past date.`, { value, expected: 'past date', actual: value }),
+        ];
+    }
+    // ------------------------------------------------------------
+    // Valid — return an empty array to indicate success.
+    // ------------------------------------------------------------
+    return [];
+};

package/dist/core/validators/date/not-after.d.ts

@@ -0,0 +1,25 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Not After
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Ensures the input is a Date instance that is not after the
+ *                  provided `max` boundary.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ValidationRule } from '../../shapes';
+/**
+ * Ensures the input is a Date instance that is not after the
+ * provided `max` boundary. The comparison is strict: value must be
+ * ≤ max.
+ *
+ * - Non-Date values emit `date.not.date`.
+ * - Invalid Date instances emit `date.is.invalid`.
+ * - Dates > max emit `date.too.late`.
+ *
+ * This rule is pure, total, async-compatible, and preserves the
+ * provided path. It supports userMessage overrides applied at the
+ * pipeline level.
+ */
+export declare const notAfter: (max: Date) => ValidationRule;

package/dist/core/validators/date/not-after.js

@@ -0,0 +1,66 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Not After
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Ensures the input is a Date instance that is not after the
+ *                  provided `max` boundary.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { validationEvent } from '../../pipeline';
+import { detectStructuralType } from '../../pipeline/scan';
+import { safeStringify } from '../../common';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Ensures the input is a Date instance that is not after the
+ * provided `max` boundary. The comparison is strict: value must be
+ * ≤ max.
+ *
+ * - Non-Date values emit `date.not.date`.
+ * - Invalid Date instances emit `date.is.invalid`.
+ * - Dates > max emit `date.too.late`.
+ *
+ * This rule is pure, total, async-compatible, and preserves the
+ * provided path. It supports userMessage overrides applied at the
+ * pipeline level.
+ */
+export const notAfter = (max) => {
+    const rule = async (value, path) => {
+        const structuralType = detectStructuralType(value);
+        // ------------------------------------------------------------
+        // Type check — the input must be a Date instance.
+        // ------------------------------------------------------------
+        if (!(value instanceof Date)) {
+            return [
+                validationEvent('error', 'date.not.date', path, `Expected 'Date' but received '${structuralType}'.`, `Please provide a valid date.`, { value, expected: 'Date', actual: structuralType }),
+            ];
+        }
+        // ------------------------------------------------------------
+        // Validity check — reject invalid Date instances.
+        // ------------------------------------------------------------
+        if (isNaN(value.getTime())) {
+            return [
+                validationEvent('error', 'date.is.invalid', path, `Date value is invalid.`, `Please provide a valid date.`, { value, expected: 'valid Date', actual: value }),
+            ];
+        }
+        // ------------------------------------------------------------
+        // Boundary check — must be ≤ max.
+        // ------------------------------------------------------------
+        if (value.getTime() > max.getTime()) {
+            return [
+                validationEvent('error', 'date.too.late', path, `${safeStringify(value)} must not be after ${max.toISOString()}.`, `Please provide an earlier date.`, { value, expected: `<= ${max.toISOString()}`, actual: value.toISOString() }),
+            ];
+        }
+        // ------------------------------------------------------------
+        // Valid — return an empty array to indicate success.
+        // ------------------------------------------------------------
+        return [];
+    };
+    // Mark as factory to preserve captured `max` value
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    rule.__janeFactory = true;
+    return rule;
+};

package/dist/core/validators/date/not-before.d.ts

@@ -0,0 +1,25 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Not Before
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Ensures the input is a Date instance that is not before the
+ *                  provided `min` boundary.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ValidationRule } from '../../shapes';
+/**
+ * Ensures the input is a Date instance that is not before the
+ * provided `min` boundary. The comparison is inclusive: value must be
+ * ≥ min.
+ *
+ * - Non-Date values emit `date.not.date`.
+ * - Invalid Date instances emit `date.is.invalid`.
+ * - Dates < min emit `date.too.early`.
+ *
+ * This rule is pure, total, async-compatible, and preserves the
+ * provided path. It supports userMessage overrides applied at the
+ * pipeline level.
+ */
+export declare const notBefore: (min: Date) => ValidationRule;

package/dist/core/validators/date/not-before.js

@@ -0,0 +1,66 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Not Before
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Ensures the input is a Date instance that is not before the
+ *                  provided `min` boundary.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { validationEvent } from '../../pipeline';
+import { detectStructuralType } from '../../pipeline/scan';
+import { safeStringify } from '../../common';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Ensures the input is a Date instance that is not before the
+ * provided `min` boundary. The comparison is inclusive: value must be
+ * ≥ min.
+ *
+ * - Non-Date values emit `date.not.date`.
+ * - Invalid Date instances emit `date.is.invalid`.
+ * - Dates < min emit `date.too.early`.
+ *
+ * This rule is pure, total, async-compatible, and preserves the
+ * provided path. It supports userMessage overrides applied at the
+ * pipeline level.
+ */
+export const notBefore = (min) => {
+    const rule = async (value, path) => {
+        const structuralType = detectStructuralType(value);
+        // ------------------------------------------------------------
+        // Type check — the input must be a Date instance.
+        // ------------------------------------------------------------
+        if (!(value instanceof Date)) {
+            return [
+                validationEvent('error', 'date.not.date', path, `Expected 'Date' but received '${structuralType}'.`, `Please provide a valid date.`, { value, expected: 'Date', actual: structuralType }),
+            ];
+        }
+        // ------------------------------------------------------------
+        // Validity check — reject invalid Date instances.
+        // ------------------------------------------------------------
+        if (isNaN(value.getTime())) {
+            return [
+                validationEvent('error', 'date.is.invalid', path, `Date value is invalid.`, `Please provide a valid date.`, { value, expected: 'valid Date', actual: value }),
+            ];
+        }
+        // ------------------------------------------------------------
+        // Boundary check — must be ≥ min.
+        // ------------------------------------------------------------
+        if (value.getTime() < min.getTime()) {
+            return [
+                validationEvent('error', 'date.too.early', path, `${safeStringify(value)} must not be before ${min.toISOString()}.`, `Please provide a later date.`, { value, expected: `>= ${min.toISOString()}`, actual: value.toISOString() }),
+            ];
+        }
+        // ------------------------------------------------------------
+        // Valid — return an empty array to indicate success.
+        // ------------------------------------------------------------
+        return [];
+    };
+    // Mark as factory to preserve captured `min` value
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    rule.__janeFactory = true;
+    return rule;
+};

package/dist/core/validators/date/same-day.d.ts

@@ -0,0 +1,25 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Same Day
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Ensures the input is a Date instance representing the same
+ *                  calendar day (year, month, day) as the provided `other`
+ *                  date.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ValidationRule } from '../../shapes';
+/**
+ * Ensures the input is a Date instance representing the same
+ * calendar day (year, month, day) as the provided `other` date.
+ *
+ * - Non-Date values emit `date.not.date`.
+ * - Invalid Date instances emit `date.is.invalid`.
+ * - Dates not matching the same Y/M/D emit `date.not.same-day`.
+ *
+ * This rule is pure, total, async-compatible, and preserves the
+ * provided path. It supports userMessage overrides applied at the
+ * pipeline level.
+ */
+export declare const sameDay: (other: Date) => ValidationRule;

package/dist/core/validators/date/same-day.js

@@ -0,0 +1,60 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Same Day
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Ensures the input is a Date instance representing the same
+ *                  calendar day (year, month, day) as the provided `other`
+ *                  date.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { validationEvent } from '../../pipeline';
+import { safeStringify } from '../../common';
+import { detectStructuralType } from '../../pipeline/scan';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Ensures the input is a Date instance representing the same
+ * calendar day (year, month, day) as the provided `other` date.
+ *
+ * - Non-Date values emit `date.not.date`.
+ * - Invalid Date instances emit `date.is.invalid`.
+ * - Dates not matching the same Y/M/D emit `date.not.same-day`.
+ *
+ * This rule is pure, total, async-compatible, and preserves the
+ * provided path. It supports userMessage overrides applied at the
+ * pipeline level.
+ */
+export const sameDay = (other) => {
+    const rule = async (value, path) => {
+        const structuralType = detectStructuralType(value);
+        if (!(value instanceof Date)) {
+            return [
+                validationEvent('error', 'date.not.date', path, `Expected 'Date' but received '${structuralType}'.`, `Please provide a valid date.`, { value, expected: 'Date', actual: structuralType }),
+            ];
+        }
+        if (isNaN(value.getTime())) {
+            return [
+                validationEvent('error', 'date.is.invalid', path, `Date value is invalid.`, `Please provide a valid date.`, { value, expected: 'valid Date', actual: value }),
+            ];
+        }
+        const isSame = value.getUTCFullYear() === other.getUTCFullYear() &&
+            value.getUTCMonth() === other.getUTCMonth() &&
+            value.getUTCDate() === other.getUTCDate();
+        if (!isSame) {
+            return [
+                validationEvent('error', 'date.not.same-day', path, `${safeStringify(value)} must be the same day as ${other.toISOString()}.`, `Please provide the correct date.`, {
+                    value,
+                    expected: other.toISOString().slice(0, 10),
+                    actual: value.toISOString().slice(0, 10),
+                }),
+            ];
+        }
+        return [];
+    };
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    rule.__janeFactory = true;
+    return rule;
+};

package/dist/core/validators/date/same-month.d.ts

@@ -0,0 +1,25 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Same Month
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Ensures the input is a Date instance representing a date in
+ *                  the same calendar month (year + month) as the provided
+ *                  `other` date.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ValidationRule } from '../../shapes';
+/**
+ * Ensures the input is a Date instance representing a date in the
+ * same calendar month (year + month) as the provided `other` date.
+ *
+ * - Non-Date values emit `date.not.date`.
+ * - Invalid Date instances emit `date.is.invalid`.
+ * - Dates not matching the same Y/M emit `date.not.same-month`.
+ *
+ * This rule is pure, total, async-compatible, and preserves the
+ * provided path. It supports userMessage overrides applied at the
+ * pipeline level.
+ */
+export declare const sameMonth: (other: Date) => ValidationRule;

package/dist/core/validators/date/same-month.js

@@ -0,0 +1,59 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Same Month
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Ensures the input is a Date instance representing a date in
+ *                  the same calendar month (year + month) as the provided
+ *                  `other` date.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { validationEvent } from '../../pipeline';
+import { safeStringify } from '../../common';
+import { detectStructuralType } from '../../pipeline/scan';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Ensures the input is a Date instance representing a date in the
+ * same calendar month (year + month) as the provided `other` date.
+ *
+ * - Non-Date values emit `date.not.date`.
+ * - Invalid Date instances emit `date.is.invalid`.
+ * - Dates not matching the same Y/M emit `date.not.same-month`.
+ *
+ * This rule is pure, total, async-compatible, and preserves the
+ * provided path. It supports userMessage overrides applied at the
+ * pipeline level.
+ */
+export const sameMonth = (other) => {
+    const rule = async (value, path) => {
+        const structuralType = detectStructuralType(value);
+        if (!(value instanceof Date)) {
+            return [
+                validationEvent('error', 'date.not.date', path, `Expected 'Date' but received '${structuralType}'.`, `Please provide a valid date.`, { value, expected: 'Date', actual: structuralType }),
+            ];
+        }
+        if (isNaN(value.getTime())) {
+            return [
+                validationEvent('error', 'date.is.invalid', path, `Date value is invalid.`, `Please provide a valid date.`, { value, expected: 'valid Date', actual: value }),
+            ];
+        }
+        const isSame = value.getUTCFullYear() === other.getUTCFullYear() &&
+            value.getUTCMonth() === other.getUTCMonth();
+        if (!isSame) {
+            return [
+                validationEvent('error', 'date.not.same-month', path, `${safeStringify(value)} must be in the same month as ${other.toISOString()}.`, `Please provide a date in the correct month.`, {
+                    value,
+                    expected: other.toISOString().slice(0, 7), // YYYY-MM
+                    actual: value.toISOString().slice(0, 7),
+                }),
+            ];
+        }
+        return [];
+    };
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    rule.__janeFactory = true;
+    return rule;
+};

package/dist/core/validators/date/same-year.d.ts

@@ -0,0 +1,24 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Same Year
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Ensures the input is a Date instance representing a date in
+ *                  the same calendar year as the provided `other` date.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ValidationRule } from '../../shapes';
+/**
+ * Ensures the input is a Date instance representing a date in the
+ * same calendar year as the provided `other` date.
+ *
+ * - Non-Date values emit `date.not.date`.
+ * - Invalid Date instances emit `date.is.invalid`.
+ * - Dates not matching the same year emit `date.not.same-year`.
+ *
+ * This rule is pure, total, async-compatible, and preserves the
+ * provided path. It supports userMessage overrides applied at the
+ * pipeline level.
+ */
+export declare const sameYear: (other: Date) => ValidationRule;

package/dist/core/validators/date/same-year.js

@@ -0,0 +1,56 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Same Year
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Ensures the input is a Date instance representing a date in
+ *                  the same calendar year as the provided `other` date.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { validationEvent } from '../../pipeline';
+import { safeStringify } from '../../common';
+import { detectStructuralType } from '../../pipeline/scan';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Ensures the input is a Date instance representing a date in the
+ * same calendar year as the provided `other` date.
+ *
+ * - Non-Date values emit `date.not.date`.
+ * - Invalid Date instances emit `date.is.invalid`.
+ * - Dates not matching the same year emit `date.not.same-year`.
+ *
+ * This rule is pure, total, async-compatible, and preserves the
+ * provided path. It supports userMessage overrides applied at the
+ * pipeline level.
+ */
+export const sameYear = (other) => {
+    const rule = async (value, path) => {
+        const structuralType = detectStructuralType(value);
+        if (!(value instanceof Date)) {
+            return [
+                validationEvent('error', 'date.not.date', path, `Expected 'Date' but received '${structuralType}'.`, `Please provide a valid date.`, { value, expected: 'Date', actual: structuralType }),
+            ];
+        }
+        if (isNaN(value.getTime())) {
+            return [
+                validationEvent('error', 'date.is.invalid', path, `Date value is invalid.`, `Please provide a valid date.`, { value, expected: 'valid Date', actual: value }),
+            ];
+        }
+        if (value.getUTCFullYear() !== other.getUTCFullYear()) {
+            return [
+                validationEvent('error', 'date.not.same-year', path, `${safeStringify(value)} must be in the same year as ${other.toISOString()}.`, `Please provide a date in the correct year.`, {
+                    value,
+                    expected: other.toISOString().slice(0, 4),
+                    actual: value.toISOString().slice(0, 4),
+                }),
+            ];
+        }
+        return [];
+    };
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    rule.__janeFactory = true;
+    return rule;
+};

package/dist/core/validators/date/too-early.d.ts

@@ -0,0 +1,25 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Too Early
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Ensures the input is a Date instance that is not earlier
+ *                  than the provided `min` boundary.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ValidationRule } from '../../shapes';
+/**
+ * Ensures the input is a Date instance that is not earlier than the
+ * provided `min` boundary. The comparison is inclusive: value must be
+ * ≥ min.
+ *
+ * - Non-Date values emit `date.not.date`.
+ * - Invalid Date instances emit `date.is.invalid`.
+ * - Dates < min emit `date.too.early`.
+ *
+ * This rule is pure, total, async-compatible, and preserves the
+ * provided path. It supports userMessage overrides applied at the
+ * pipeline level.
+ */
+export declare const tooEarly: (min: Date) => ValidationRule;

package/dist/core/validators/date/too-early.js

@@ -0,0 +1,57 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Too Early
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Ensures the input is a Date instance that is not earlier
+ *                  than the provided `min` boundary.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { validationEvent } from '../../pipeline';
+import { detectStructuralType } from '../../pipeline/scan';
+import { safeStringify } from '../../common';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Ensures the input is a Date instance that is not earlier than the
+ * provided `min` boundary. The comparison is inclusive: value must be
+ * ≥ min.
+ *
+ * - Non-Date values emit `date.not.date`.
+ * - Invalid Date instances emit `date.is.invalid`.
+ * - Dates < min emit `date.too.early`.
+ *
+ * This rule is pure, total, async-compatible, and preserves the
+ * provided path. It supports userMessage overrides applied at the
+ * pipeline level.
+ */
+export const tooEarly = (min) => {
+    const rule = async (value, path) => {
+        const structuralType = detectStructuralType(value);
+        if (!(value instanceof Date)) {
+            return [
+                validationEvent('error', 'date.not.date', path, `Expected 'Date' but received '${structuralType}'.`, `Please provide a valid date.`, { value, expected: 'Date', actual: structuralType }),
+            ];
+        }
+        if (isNaN(value.getTime())) {
+            return [
+                validationEvent('error', 'date.is.invalid', path, `Date value is invalid.`, `Please provide a valid date.`, { value, expected: 'valid Date', actual: value }),
+            ];
+        }
+        if (value.getTime() < min.getTime()) {
+            return [
+                validationEvent('error', 'date.too.early', path, `${safeStringify(value)} must not be earlier than ${min.toISOString()}.`, `Please provide a later date.`, {
+                    value: value.toISOString(),
+                    expected: `>= ${min.toISOString()}`,
+                    actual: value.toISOString(),
+                }),
+            ];
+        }
+        return [];
+    };
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    rule.__janeFactory = true;
+    return rule;
+};

package/dist/core/validators/date/too-late.d.ts

@@ -0,0 +1,25 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Too Early
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Ensures the input is a Date instance that is not later than
+ *                  the provided `max` boundary.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ValidationRule } from '../../shapes';
+/**
+ * Ensures the input is a Date instance that is not later than the
+ * provided `max` boundary. The comparison is inclusive: value must be
+ * ≤ max.
+ *
+ * - Non-Date values emit `date.not.date`.
+ * - Invalid Date instances emit `date.is.invalid`.
+ * - Dates > max emit `date.too.late`.
+ *
+ * This rule is pure, total, async-compatible, and preserves the
+ * provided path. It supports userMessage overrides applied at the
+ * pipeline level.
+ */
+export declare const tooLate: (max: Date) => ValidationRule;