@clementine-solutions/jane-io 1.0.0 → 1.0.1

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;

package/dist/core/validators/date/weekday.d.ts

@@ -0,0 +1,32 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Weekday
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Ensures the input is a Date instance whose weekday (0–6)
+ *                  matches the required weekday.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ValidationRule } from '../../shapes';
+/**
+ * Ensures the input is a Date instance whose weekday (0–6) matches
+ * the required weekday. JavaScript uses:
+ *
+ *   0 = Sunday
+ *   1 = Monday
+ *   2 = Tuesday
+ *   3 = Wednesday
+ *   4 = Thursday
+ *   5 = Friday
+ *   6 = Saturday
+ *
+ * - Non-Date values emit `date.not.date`.
+ * - Invalid Date instances emit `date.is.invalid`.
+ * - Mismatched weekdays emit `date.not.weekday`.
+ *
+ * This rule is pure, total, async-compatible, and preserves the
+ * provided path. It supports userMessage overrides applied at the
+ * pipeline level.
+ */
+export declare const weekday: (required: number) => ValidationRule;

package/dist/core/validators/date/weekend.d.ts

@@ -0,0 +1,27 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Weekend
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Ensures the input is a Date instance that falls on a
+ *                  weekend.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ValidationRule } from '../../shapes';
+/**
+ * Ensures the input is a Date instance that falls on a weekend.
+ *
+ * JavaScript weekday values:
+ *   0 = Sunday
+ *   6 = Saturday
+ *
+ * - Non-Date values emit `date.not.date`.
+ * - Invalid Date instances emit `date.is.invalid`.
+ * - Weekdays (1–5) emit `date.not.weekend`.
+ *
+ * This rule is pure, total, async-compatible, and preserves the
+ * provided path. It supports userMessage overrides applied at the
+ * pipeline level.
+ */
+export declare const weekend: ValidationRule;

package/dist/core/validators/index.d.ts

@@ -0,0 +1,112 @@
+/**
+ * ----------------------------------------------------------------------------
+ *  Validators | Barrel File
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Re‑exports all built‑in validation rules, providing a single
+ *                  cohesive entry point for Jane’s validation subsystem. This
+ *                  keeps contributor onboarding simple and ensures consistent,
+ *                  predictable resolution of validator names across the
+ *                  framework.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+export { array } from './array/array';
+export { arrayMaxItems } from './array/array-max-items';
+export { arrayMinItems } from './array/array-min-items';
+export { excludes } from './array/excludes';
+export { hasUniqueItems } from './array/has-unique-items';
+export { includes } from './array/includes';
+export { itemsEqual } from './array/items-equal';
+export { noEmptyStringItems } from './array/no-empty-string-items';
+export { noNullItems } from './array/no-null-items';
+export { noUndefinedItems } from './array/no-undefined-items';
+export { nonEmptyArray } from './array/non-empty-array';
+export { notSparse } from './array/not-sparse';
+export { bigint } from './bigint/bigint';
+export { bigintEquals } from './bigint/bigint-equals';
+export { bigintMax } from './bigint/bigint-max';
+export { bigintMin } from './bigint/bigint-min';
+export { bigintNegative } from './bigint/bigint-negative';
+export { bigintNonNegative } from './bigint/bigint-non-negative';
+export { bigintNonPositive } from './bigint/bigint-non-positive';
+export { bigintPositive } from './bigint/bigint-positive';
+export { bigintSafe } from './bigint/bigint-safe';
+export { boolean } from './boolean/boolean';
+export { isFalse } from './boolean/is-false';
+export { isTrue } from './boolean/is-true';
+export { isCountryCode } from './common/is-country-code';
+export { isCurrencyCode } from './common/is-currency-code';
+export { isEmail } from './common/is-email';
+export { isEmailStrict } from './common/is-email-strict';
+export { isIp } from './common/is-ip';
+export { isPhone } from './common/is-phone';
+export { isPhoneStrict } from './common/is-phone-strict';
+export { isPort } from './common/is-port';
+export { isPostalCode } from './common/is-postal-code';
+export { isUrl } from './common/is-url';
+export { isUuid } from './common/is-uuid';
+export { beforeEpoch } from './date/before-epoch';
+export { dateNowRequired } from './date/date-now-required';
+export { isDate } from './date/is-date';
+export { isFarFuture } from './date/is-far-future';
+export { isFuture } from './date/is-future';
+export { isPast } from './date/is-past';
+export { notAfter } from './date/not-after';
+export { notBefore } from './date/not-before';
+export { sameDay } from './date/same-day';
+export { sameMonth } from './date/same-month';
+export { sameYear } from './date/same-year';
+export { tooEarly } from './date/too-early';
+export { tooLate } from './date/too-late';
+export { weekday } from './date/weekday';
+export { weekend } from './date/weekend';
+export { isNull } from './nullish/is-null';
+export { isNullOrUndefined } from './nullish/is-null-or-undefined';
+export { isUndefined } from './nullish/is-undefined';
+export { finite } from './number/finite';
+export { integer } from './number/integer';
+export { lessThan } from './number/less-than';
+export { max } from './number/max';
+export { min } from './number/min';
+export { moreThan } from './number/more-than';
+export { negative } from './number/negative';
+export { nonNegative } from './number/non-negative';
+export { nonPositive } from './number/non-positive';
+export { number } from './number/number';
+export { positive } from './number/positive';
+export { safeInteger } from './number/safe-integer';
+export { deepEquals } from './object/deep-equals';
+export { hasKey } from './object/has-key';
+export { hasValue } from './object/has-value';
+export { keysEqual } from './object/keys-equal';
+export { maxKeys } from './object/max-keys';
+export { minKeys } from './object/min-keys';
+export { missingKey } from './object/missing-key';
+export { noEmptyArrayValues } from './object/no-empty-array-values';
+export { noEmptyObjectValues } from './object/no-empty-object-values';
+export { noNullValues } from './object/no-null-values';
+export { noUndefinedValues } from './object/no-undefined-values';
+export { nonEmptyObject } from './object/non-empty-object';
+export { plainObject } from './object/plain-object';
+export { onlyKeys } from './object/only-keys';
+export { alpha } from './string/alpha';
+export { alphaNum } from './string/alpha-num';
+export { charsEqual } from './string/chars-equal';
+export { endsWith } from './string/ends-with';
+export { isAscii } from './string/is-ascii';
+export { isPrintable } from './string/is-printable';
+export { matches } from './string/matches';
+export { maxLength } from './string/max-length';
+export { minLength } from './string/min-length';
+export { noLeadSpace } from './string/no-lead-space';
+export { noRepeatSpace } from './string/no-repeat-space';
+export { noSpace } from './string/no-space';
+export { noTrailSpace } from './string/no-trail-space';
+export { nonEmpty } from './string/non-empty';
+export { notOneOf } from './string/not-one-of';
+export { numString } from './string/num-string';
+export { oneOf } from './string/one-of';
+export { startsWith } from './string/starts-with';
+export { string } from './string/string';
+export { trimmed } from './string/trimmed';

package/dist/core/validators/nullish/is-null-or-undefined.d.ts

@@ -0,0 +1,22 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Is Null Or Undefined
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validates that the value is either `null` or `undefined`.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ValidationRule } from '../../shapes';
+/**
+ * Validates that the value is either `null` or `undefined`.
+ *
+ * - Any value other than `null` or `undefined` emits
+ *   `value.not.null-or-undefined`.
+ * - Returns an empty array when the value is valid.
+ *
+ * This rule is pure, total, async‑compatible, and returns a readonly array of
+ * JaneEvent objects. It preserves the provided path and supports userMessage
+ * overrides applied at the pipeline level.
+ */
+export declare const isNullOrUndefined: ValidationRule;

package/dist/core/validators/nullish/is-null.d.ts

@@ -0,0 +1,21 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Is Null
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validates that the value is exactly `null`.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ValidationRule } from '../../shapes';
+/**
+ * Validates that the value is exactly `null`.
+ *
+ * - Any value other than `null` emits `value.not.null`.
+ * - Returns an empty array when the value is valid.
+ *
+ * This rule is pure, total, async‑compatible, and returns a readonly array of
+ * JaneEvent objects. It preserves the provided path and supports userMessage
+ * overrides applied at the pipeline level.
+ */
+export declare const isNull: ValidationRule;

package/dist/core/validators/nullish/is-undefined.d.ts

@@ -0,0 +1,21 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Is Undefined
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validates that the value is exactly `undefined`.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ValidationRule } from '../../shapes';
+/**
+ * Validates that the value is exactly `undefined`.
+ *
+ * - Any value other than `undefined` emits `value.not.undefined`.
+ * - Returns an empty array when the value is valid.
+ *
+ * This rule is pure, total, async‑compatible, and returns a readonly array of
+ * JaneEvent objects. It preserves the provided path and supports userMessage
+ * overrides applied at the pipeline level.
+ */
+export declare const isUndefined: ValidationRule;

package/dist/core/validators/number/finite.d.ts

@@ -0,0 +1,22 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Finite
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validate that the value is a finite number.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ValidationRule } from '../../shapes';
+/**
+ * Validate that the value is a finite number.
+ *
+ * This rule accepts only JavaScript numbers that are both numeric and finite.
+ * Non-number values, NaN, Infinity, and -Infinity are rejected.
+ *
+ * If the value is not a number, a type.not.valid event is emitted.
+ * If the value is a number but not finite, a number.not.finite event is emitted.
+ *
+ * The rule is async-compatible and returns a readonly array of JaneEvent objects.
+ */
+export declare const finite: ValidationRule;

package/dist/core/validators/number/integer.d.ts

@@ -0,0 +1,22 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Integer
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validate that the value is an integer.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ValidationRule } from '../../shapes';
+/**
+ * Validate that the value is an integer.
+ *
+ * This rule accepts only JavaScript numbers that are both numeric and integer‑valued.
+ * Non-number values and non-integer numbers are rejected.
+ *
+ * If the value is not a number, a type.not.valid event is emitted.
+ * If the value is a number but not an integer, a number.not.integer event is emitted.
+ *
+ * The rule is async-compatible and returns a readonly array of JaneEvent objects.
+ */
+export declare const integer: ValidationRule;

package/dist/core/validators/number/less-than.d.ts

@@ -0,0 +1,21 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Less Than
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validate that the value is a number strictly less than the
+ *                  given limit.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ValidationRule } from '../../shapes';
+/**
+ * Validate that the value is a number strictly less than the given limit.
+ *
+ * This rule accepts only JavaScript numbers. Non-number values are rejected.
+ * If the value is numeric but not less than the provided limit, a
+ * number.too.high event is emitted.
+ *
+ * The rule is async-compatible and returns a readonly array of JaneEvent objects.
+ */
+export declare const lessThan: (limit: number) => ValidationRule;

package/dist/core/validators/number/max.d.ts

@@ -0,0 +1,21 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Maximum (Max)
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validate that the value is a number less than or equal to
+ *                  the given limit.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ValidationRule } from '../../shapes';
+/**
+ * Validate that the value is a number less than or equal to the given limit.
+ *
+ * This rule accepts only JavaScript numbers. Non-number values are rejected.
+ * If the value is numeric but greater than the provided limit, a
+ * number.too.high event is emitted.
+ *
+ * The rule is async-compatible and returns a readonly array of JaneEvent objects.
+ */
+export declare const max: (limit: number) => ValidationRule;

package/dist/core/validators/number/min.d.ts

@@ -0,0 +1,21 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Minimum (Min)
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validate that the value is a number greater than or equal
+ *                  to the given limit.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ValidationRule } from '../../shapes';
+/**
+ * Validate that the value is a number greater than or equal to the given limit.
+ *
+ * This rule accepts only JavaScript numbers. Non-number values are rejected.
+ * If the value is numeric but less than the provided limit, a
+ * number.too.low event is emitted.
+ *
+ * The rule is async-compatible and returns a readonly array of JaneEvent objects.
+ */
+export declare const min: (limit: number) => ValidationRule;

package/dist/core/validators/number/more-than.d.ts

@@ -0,0 +1,21 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | More Than
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validate that the value is a number strictly greater than
+ *                  the given limit.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ValidationRule } from '../../shapes';
+/**
+ * Validate that the value is a number strictly greater than the given limit.
+ *
+ * This rule accepts only JavaScript numbers. Non-number values and NaN are rejected.
+ * If the value is numeric but not greater than the provided limit, a
+ * number.too.low event is emitted.
+ *
+ * The rule is async-compatible and returns a readonly array of JaneEvent objects.
+ */
+export declare const moreThan: (limit: number) => ValidationRule;

package/dist/core/validators/number/negative.d.ts

@@ -0,0 +1,20 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Negative
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validate that the value is a negative number.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ValidationRule } from '../../shapes';
+/**
+ * Validate that the value is a negative number.
+ *
+ * This rule accepts only JavaScript numbers. Non-number values and NaN are rejected.
+ * If the value is numeric but not strictly less than zero, a number.not.negative
+ * event is emitted.
+ *
+ * The rule is async-compatible and returns a readonly array of JaneEvent objects.
+ */
+export declare const negative: ValidationRule;

package/dist/core/validators/number/non-negative.d.ts

@@ -0,0 +1,19 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Non-Negative
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validate that the value is a non‑negative number.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ValidationRule } from '../../shapes';
+/**
+ * Validate that the value is a non‑negative number.
+ *
+ * This rule accepts only JavaScript numbers. Non-number values and NaN are rejected.
+ * If the value is numeric but less than zero, a number.not.non-negative event is emitted.
+ *
+ * The rule is async-compatible and returns a readonly array of JaneEvent objects.
+ */
+export declare const nonNegative: ValidationRule;

package/dist/core/validators/number/non-positive.d.ts

@@ -0,0 +1,19 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Non Positive
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validate that the value is a non‑positive number.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ValidationRule } from '../../shapes';
+/**
+ * Validate that the value is a non‑positive number.
+ *
+ * This rule accepts only JavaScript numbers. Non-number values and NaN are rejected.
+ * If the value is numeric but greater than zero, a number.not.non-positive event is emitted.
+ *
+ * The rule is async-compatible and returns a readonly array of JaneEvent objects.
+ */
+export declare const nonPositive: ValidationRule;

package/dist/core/validators/number/number.d.ts

@@ -0,0 +1,19 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Number
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validate that the value is a JavaScript number.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ValidationRule } from '../../shapes';
+/**
+ * Validate that the value is a JavaScript number.
+ *
+ * This rule accepts only JavaScript numbers. Non-number values and NaN are rejected.
+ * If the value is not a number, a type.not.valid event is emitted.
+ *
+ * The rule is async-compatible and returns a readonly array of JaneEvent objects.
+ */
+export declare const number: ValidationRule;

package/dist/core/validators/number/positive.d.ts

@@ -0,0 +1,20 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Positive
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validate that the value is a positive number.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ValidationRule } from '../../shapes';
+/**
+ * Validate that the value is a positive number.
+ *
+ * This rule accepts only JavaScript numbers. Non-number values and NaN are rejected.
+ * If the value is numeric but not strictly greater than zero, a number.not.positive
+ * event is emitted.
+ *
+ * The rule is async-compatible and returns a readonly array of JaneEvent objects.
+ */
+export declare const positive: ValidationRule;

package/dist/core/validators/number/safe-integer.d.ts

@@ -0,0 +1,19 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Safe Integer
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validates that a value is a safe integer.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ValidationRule } from '../../shapes';
+/**
+ * Validates that a value is a safe integer.
+ *
+ * Safe integers must be whole numbers that fall within JavaScript’s
+ * IEEE‑754 safe range. This protects downstream logic from precision loss,
+ * overflow‑adjacent behavior, and malformed numeric input that appears valid
+ * but cannot be represented exactly.
+ */
+export declare const safeInteger: ValidationRule;

package/dist/core/validators/object/deep-equals.d.ts

@@ -0,0 +1,24 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Deep Equals
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validate that a value is deeply equal to an expected
+ *                  structural value.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ValidationRule } from '../../shapes';
+/**
+ * Validate that a value is deeply equal to an expected structural value.
+ *
+ * Deep equality is performed against JSON-compatible values only:
+ * - primitives
+ * - arrays
+ * - plain objects (no class instances, Maps, Sets, Dates, etc.)
+ *
+ * If the value is not structural, an object.not.plain-object event is emitted.
+ * If the value is structural but not deeply equal, an object.not.deeply-equal event is emitted.
+ * The rule is async-compatible and returns a readonly array of JaneEvent objects.
+ */
+export declare const deepEquals: (expected: unknown) => ValidationRule;

package/dist/core/validators/object/has-key.d.ts

@@ -0,0 +1,23 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Has Key
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validate that a plain object contains a required own
+ *                  enumerable key.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ValidationRule } from '../../shapes';
+/**
+ * Validate that a plain object contains a required own enumerable key.
+ *
+ * This rule accepts only JSON-compatible plain objects (prototype === Object.prototype).
+ * Arrays, null, class instances, Maps, Sets, Dates, and other non-plain objects are rejected.
+ *
+ * If the value is not a plain object, an object.not.plain-object event is emitted.
+ * If the required key is missing, an object.missing-key event is emitted.
+ *
+ * The rule is async-compatible and returns a readonly array of JaneEvent objects.
+ */
+export declare const hasKey: (requiredKey: string) => ValidationRule;

package/dist/core/validators/object/has-value.d.ts

@@ -0,0 +1,27 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Has Value
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validate that an array or plain object contains a value
+ *                  deeply equal to the target.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ValidationRule } from '../../shapes';
+/**
+ * Validate that an array or plain object contains a value deeply equal to the target.
+ *
+ * This rule accepts only JSON-compatible arrays and plain objects.
+ * Primitives, null, class instances, Maps, Sets, Dates, and other non-collection
+ * values are rejected.
+ *
+ * Arrays are searched using deep equality on each element.
+ * Objects are searched using deep equality on each own enumerable value.
+ *
+ * If the value is not a collection, an object.not.collection event is emitted.
+ * If the target value is not found, a value.not.found event is emitted.
+ *
+ * The rule is async-compatible and returns a readonly array of JaneEvent objects.
+ */
+export declare const hasValue: (target: unknown) => ValidationRule;

package/dist/core/validators/object/keys-equal.d.ts

@@ -0,0 +1,26 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Validators | Keys Equal
+ * ----------------------------------------------------------------------------
+ * @package         @clementine-solutions/jane
+ * @description     Validate that a plain object contains exactly the expected
+ *                  set of keys.
+ * @see             https://jane-io.com
+ * ----------------------------------------------------------------------------
+ */
+import type { ValidationRule } from '../../shapes';
+/**
+ * Validate that a plain object contains exactly the expected set of keys.
+ *
+ * This rule accepts only JSON-compatible plain objects (prototype === Object.prototype).
+ * Arrays, null, class instances, Maps, Sets, Dates, and other non-plain objects are rejected.
+ *
+ * The object must contain the same number of keys and the same key names as expectedKeys.
+ * Order does not matter. Keys must match exactly.
+ *
+ * If the value is not a plain object, an object.not.plain-object event is emitted.
+ * If the key set does not match, an object.invalid-keys event is emitted.
+ *
+ * The rule is async-compatible and returns a readonly array of JaneEvent objects.
+ */
+export declare const keysEqual: (expectedKeys: readonly string[]) => ValidationRule;