@clementine-solutions/jane-io 1.0.0 → 1.0.2

package/dist/core/validators/common/is-port.js

@@ -0,0 +1,35 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Is Port
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validates TCP/UDP port numbers.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { validationEvent } from '../../pipeline';
+import { detectStructuralType } from '../../pipeline/scan';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Validates TCP/UDP port numbers.
+ *
+ * Ports must be integers between 0 and 65535. This prevents invalid or
+ * out‑of‑range port values from being accepted.
+ */
+export const isPort = async (value, path) => {
+    const type = detectStructuralType(value);
+    if (type !== 'number') {
+        return [
+            validationEvent('error', 'type.not.valid', path, `Expected 'number' but received '${type}'.`, `Please provide a valid port number.`, { value, expected: 'number', actual: type }),
+        ];
+    }
+    const n = value;
+    if (!Number.isInteger(n) || n < 0 || n > 65535) {
+        return [
+            validationEvent('error', 'number.not.in-port-range', path, `Port must be an integer between 0 and 65535.`, `Please provide a valid port number.`, { value, min: 0, max: 65535 }),
+        ];
+    }
+    return [];
+};

package/dist/core/validators/common/is-postal-code.d.ts

@@ -0,0 +1,17 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Is Postal Code
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validates alphanumeric postal codes.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ValidationRule } from '../../shapes';
+/**
+ * Validates alphanumeric postal codes.
+ *
+ * Accepts letters, digits, spaces, and hyphens within a reasonable length
+ * range, supporting a wide variety of international postal formats.
+ */
+export declare const isPostalCode: ValidationRule;

package/dist/core/validators/common/is-postal-code.js

@@ -0,0 +1,36 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Is Postal Code
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validates alphanumeric postal codes.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { validationEvent } from '../../pipeline';
+import { safeStringify } from '../../common';
+import { detectStructuralType } from '../../pipeline/scan';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Validates alphanumeric postal codes.
+ *
+ * Accepts letters, digits, spaces, and hyphens within a reasonable length
+ * range, supporting a wide variety of international postal formats.
+ */
+export const isPostalCode = async (value, path) => {
+    const type = detectStructuralType(value);
+    if (type !== 'string') {
+        return [
+            validationEvent('error', 'type.not.valid', path, `Expected 'string' but received '${type}'.`, `Please provide a valid postal code.`, { value, expected: 'string', actual: type }),
+        ];
+    }
+    const re = /^[A-Za-z0-9 \\-]{3,12}$/;
+    if (!re.test(value)) {
+        return [
+            validationEvent('error', 'string.not.postal-code', path, `${safeStringify(value)} is not a valid postal code.`, `Please provide a valid postal code.`, { value }),
+        ];
+    }
+    return [];
+};

package/dist/core/validators/common/is-url.d.ts

@@ -0,0 +1,17 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Is URL
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validates URLs using the WHATWG URL parser.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ValidationRule } from '../../shapes';
+/**
+ * Validates URLs using the WHATWG URL parser.
+ *
+ * Ensures the string is a syntactically valid absolute URL, preventing malformed
+ * or incomplete URL values from being accepted.
+ */
+export declare const isUrl: ValidationRule;

package/dist/core/validators/common/is-url.js

@@ -0,0 +1,38 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Is URL
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validates URLs using the WHATWG URL parser.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { validationEvent } from '../../pipeline';
+import { safeStringify } from '../../common';
+import { detectStructuralType } from '../../pipeline/scan';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Validates URLs using the WHATWG URL parser.
+ *
+ * Ensures the string is a syntactically valid absolute URL, preventing malformed
+ * or incomplete URL values from being accepted.
+ */
+export const isUrl = async (value, path) => {
+    const type = detectStructuralType(value);
+    if (type !== 'string') {
+        return [
+            validationEvent('error', 'string.not.string', path, `Expected 'string' but received '${type}'.`, `Please provide a valid URL.`, { value, expected: 'string', actual: type }),
+        ];
+    }
+    try {
+        new URL(value);
+        return [];
+    }
+    catch {
+        return [
+            validationEvent('error', 'string.not.url', path, `${safeStringify(value)} is not a valid URL.`, `Please provide a valid URL.`, { value }),
+        ];
+    }
+};

package/dist/core/validators/common/is-uuid.d.ts

@@ -0,0 +1,17 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Is UUID
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validates UUIDs (versions 1–4).
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ValidationRule } from '../../shapes';
+/**
+ * Validates UUIDs (versions 1–4).
+ *
+ * Enforces canonical hyphenated formatting and correct version/variant bits,
+ * ensuring the identifier is structurally sound and standards‑compliant.
+ */
+export declare const isUuid: ValidationRule;

package/dist/core/validators/common/is-uuid.js

@@ -0,0 +1,36 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Is UUID
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validates UUIDs (versions 1–4).
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { validationEvent } from '../../pipeline';
+import { detectStructuralType } from '../../pipeline/scan';
+import { safeStringify } from '../../common';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Validates UUIDs (versions 1–4).
+ *
+ * Enforces canonical hyphenated formatting and correct version/variant bits,
+ * ensuring the identifier is structurally sound and standards‑compliant.
+ */
+export const isUuid = async (value, path) => {
+    const type = detectStructuralType(value);
+    if (type !== 'string') {
+        return [
+            validationEvent('error', 'type.not.valid', path, `Expected 'string' but received '${type}'.`, `Please provide a valid UUID.`, { value, expected: 'string', actual: type }),
+        ];
+    }
+    const re = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-4][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$/;
+    if (!re.test(value)) {
+        return [
+            validationEvent('error', 'string.not.uuid', path, `${safeStringify(value)} is not a valid UUID (v1–v4).`, `Please provide a valid UUID.`, { value }),
+        ];
+    }
+    return [];
+};

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

@@ -0,0 +1,28 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Before Epoch
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validates that a value is a JavaScript Date occurring before
+ *                  the Unix epoch (January 1, 1970, 00:00:00 UTC).
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ValidationRule } from '../../shapes';
+/**
+ * Validates that a value is a JavaScript Date occurring before
+ * the Unix epoch (January 1, 1970, 00:00:00 UTC).
+ *
+ * This rule checks:
+ * - The value is structurally a Date instance
+ * - The date timestamp is strictly less than the Unix epoch
+ *
+ * Emits:
+ * - date.not.date        (value is not a Date)
+ * - date.not.beforeEpoch (date is on or after the Unix epoch)
+ *
+ * This rule is async-compatible and returns a readonly array
+ * of JaneEvent objects.
+ * ----------------------------------------------------------------------------
+ */
+export declare const beforeEpoch: ValidationRule;

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

@@ -0,0 +1,56 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Before Epoch
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validates that a value is a JavaScript Date occurring before
+ *                  the Unix epoch (January 1, 1970, 00:00:00 UTC).
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { validationEvent } from '../../pipeline';
+import { safeStringify } from '../../common';
+import { detectStructuralType } from '../../pipeline/scan';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Validates that a value is a JavaScript Date occurring before
+ * the Unix epoch (January 1, 1970, 00:00:00 UTC).
+ *
+ * This rule checks:
+ * - The value is structurally a Date instance
+ * - The date timestamp is strictly less than the Unix epoch
+ *
+ * Emits:
+ * - date.not.date        (value is not a Date)
+ * - date.not.beforeEpoch (date is on or after the Unix epoch)
+ *
+ * This rule is async-compatible and returns a readonly array
+ * of JaneEvent objects.
+ * ----------------------------------------------------------------------------
+ */
+export const beforeEpoch = 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,
+            }),
+        ];
+    }
+    const unixEpochMilliseconds = 0;
+    const timestamp = value.getTime();
+    if (timestamp >= unixEpochMilliseconds) {
+        return [
+            validationEvent('error', 'date.is.before-epoch', path, `${safeStringify(value)} must be before the Unix epoch.`, `Please provide a date before January 1, 1970.`, {
+                value,
+                expected: '< 1970-01-01T00:00:00.000Z',
+                actual: value.toISOString(),
+            }),
+        ];
+    }
+    return [];
+};

package/dist/core/validators/date/date-now-required.d.ts

@@ -0,0 +1,22 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Date Now Required
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Ensures the input is a Date instance representing today's
+ *                  date.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ValidationRule } from '../../shapes';
+/**
+ * Ensures the input is a Date instance representing today's date.
+ *
+ * - Non-Date values emit `date.not.date`.
+ * - Dates not matching today's year/month/day emit `date.now.undefined`.
+ *
+ * This rule is pure, total, async-compatible, and preserves the
+ * provided path. It supports userMessage overrides applied at the
+ * pipeline level.
+ */
+export declare const dateNowRequired: ValidationRule;

package/dist/core/validators/date/date-now-required.js

@@ -0,0 +1,48 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Date Now Required
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Ensures the input is a Date instance representing today's
+ *                  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 today's date.
+ *
+ * - Non-Date values emit `date.not.date`.
+ * - Dates not matching today's year/month/day emit `date.now.undefined`.
+ *
+ * This rule is pure, total, async-compatible, and preserves the
+ * provided path. It supports userMessage overrides applied at the
+ * pipeline level.
+ */
+export const dateNowRequired = 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 }),
+        ];
+    }
+    const now = new Date();
+    const isSameDay = value.getUTCFullYear() === now.getUTCFullYear() &&
+        value.getUTCMonth() === now.getUTCMonth() &&
+        value.getUTCDate() === now.getUTCDate();
+    if (!isSameDay) {
+        return [
+            validationEvent('error', 'date.now.undefined', path, `${safeStringify(value)} must be today's date.`, `Please provide today's date.`, {
+                value,
+                expected: now.toISOString().slice(0, 10),
+                actual: value.toISOString().slice(0, 10),
+            }),
+        ];
+    }
+    return [];
+};

package/dist/core/validators/date/is-date.d.ts

@@ -0,0 +1,21 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Is Date
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Ensures the input is a valid JavaScript Date instance.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ValidationRule } from '../../shapes';
+/**
+ * Ensures the input is a valid JavaScript Date instance.
+ *
+ * - Non-Date values emit `date.not.date`.
+ * - Invalid Date instances (NaN timestamp) emit `date.is.invalid`.
+ *
+ * This rule is pure, total, async-compatible, and preserves the
+ * provided path. It supports userMessage overrides applied at the
+ * pipeline level.
+ */
+export declare const isDate: ValidationRule;

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

@@ -0,0 +1,47 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Is Date
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Ensures the input is a valid JavaScript Date instance.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import { validationEvent } from '../../pipeline';
+import { detectStructuralType } from '../../pipeline/scan';
+/* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— *\
+|* Implementation                                                            *|
+\* ——— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ————— * ——— */
+/**
+ * Ensures the input is a valid JavaScript Date instance.
+ *
+ * - Non-Date values emit `date.not.date`.
+ * - Invalid Date instances (NaN timestamp) emit `date.is.invalid`.
+ *
+ * This rule is pure, total, async-compatible, and preserves the
+ * provided path. It supports userMessage overrides applied at the
+ * pipeline level.
+ */
+export const isDate = 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 — ensure the Date is not "Invalid Date".
+    // ------------------------------------------------------------
+    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 }),
+        ];
+    }
+    // ------------------------------------------------------------
+    // Valid — return an empty array to indicate success.
+    // ------------------------------------------------------------
+    return [];
+};

package/dist/core/validators/date/is-far-future.d.ts

@@ -0,0 +1,23 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Is Far Future
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Ensures the input is a Date instance representing a year
+ *                  strictly greater than 2100.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ValidationRule } from '../../shapes';
+/**
+ * Ensures the input is a Date instance representing a year strictly
+ * greater than 2100.
+ *
+ * - Non-Date values emit `date.not.date`.
+ * - Dates with year ≤ 2100 emit `date.is.far-future`.
+ *
+ * This rule is pure, total, async-compatible, and preserves the
+ * provided path. It supports userMessage overrides applied at the
+ * pipeline level.
+ */
+export declare const isFarFuture: ValidationRule;

package/dist/core/validators/date/is-far-future.js

@@ -0,0 +1,46 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Is Far Future
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Ensures the input is a Date instance representing a year
+ *                  strictly greater than 2100.
+ * @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 year strictly
+ * greater than 2100.
+ *
+ * - Non-Date values emit `date.not.date`.
+ * - Dates with year ≤ 2100 emit `date.is.far-future`.
+ *
+ * This rule is pure, total, async-compatible, and preserves the
+ * provided path. It supports userMessage overrides applied at the
+ * pipeline level.
+ */
+export const isFarFuture = 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() <= 2100) {
+        return [
+            validationEvent('error', 'date.is.far-future', path, `${safeStringify(value)} must be after the year 2100.`, `Please provide a far-future date.`, { value, expected: '> 2100', actual: value.getUTCFullYear() }),
+        ];
+    }
+    return [];
+};

package/dist/core/validators/date/is-future.d.ts

@@ -0,0 +1,24 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Is Future
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Ensures the input is a Date instance representing a moment
+ *                  strictly after the current system time.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ValidationRule } from '../../shapes';
+/**
+ * Ensures the input is a Date instance representing a moment strictly
+ * after the current system time.
+ *
+ * - Non-Date values emit `date.not.date`.
+ * - Invalid Date instances emit `date.is.invalid`.
+ * - Dates ≤ now emit `date.in.past`.
+ *
+ * This rule is pure, total, async-compatible, and preserves the
+ * provided path. It supports userMessage overrides applied at the
+ * pipeline level.
+ */
+export declare const isFuture: ValidationRule;

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

@@ -0,0 +1,59 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Is Future
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Ensures the input is a Date instance representing a moment
+ *                  strictly after the current system time.
+ * @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 moment strictly
+ * after the current system time.
+ *
+ * - Non-Date values emit `date.not.date`.
+ * - Invalid Date instances emit `date.is.invalid`.
+ * - Dates ≤ now emit `date.in.past`.
+ *
+ * This rule is pure, total, async-compatible, and preserves the
+ * provided path. It supports userMessage overrides applied at the
+ * pipeline level.
+ */
+export const isFuture = 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 }),
+        ];
+    }
+    // ------------------------------------------------------------
+    // Future check — must be strictly greater than now.
+    // ------------------------------------------------------------
+    if (value.getTime() <= Date.now()) {
+        return [
+            validationEvent('error', 'date.in.past', path, `${safeStringify(value)} must be in the future.`, `Please provide a future date.`, { value, expected: 'future date', actual: value }),
+        ];
+    }
+    // ------------------------------------------------------------
+    // Valid — return an empty array to indicate success.
+    // ------------------------------------------------------------
+    return [];
+};

package/dist/core/validators/date/is-past.d.ts

@@ -0,0 +1,24 @@
+/**
+ * ----------------------------------------------------------------------------
+ * 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 type { ValidationRule } from '../../shapes';
+/**
+ * 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 declare const isPast: ValidationRule;