n4s 6.1.12 → 6.2.0

package/src/rules/schemaRules/__tests__/tuple.test.ts

@@ -0,0 +1,256 @@
+import { describe, it, expect, expectTypeOf } from 'vitest';
+
+import { enforce } from '../../../n4s';
+
+describe('enforce.tuple()', () => {
+  describe('basic validation', () => {
+    it('passes for valid tuple', () => {
+      const schema = enforce.tuple(enforce.isString(), enforce.isNumber());
+      expect(schema.test(['hello', 42])).toBe(true);
+    });
+
+    it('fails when element has wrong type', () => {
+      const schema = enforce.tuple(enforce.isString(), enforce.isNumber());
+      // @ts-expect-error - intentionally passing wrong type for first element
+      expect(schema.test([42, 42])).toBe(false);
+      // @ts-expect-error - intentionally passing wrong type for second element
+      expect(schema.test(['hello', 'world'])).toBe(false);
+    });
+
+    it('fails when too few elements', () => {
+      const schema = enforce.tuple(enforce.isString(), enforce.isNumber());
+      // @ts-expect-error - intentionally passing too few elements
+      expect(schema.test(['hello'])).toBe(false);
+    });
+
+    it('fails when too many elements', () => {
+      const schema = enforce.tuple(enforce.isString(), enforce.isNumber());
+      // @ts-expect-error - intentionally passing too many elements
+      expect(schema.test(['hello', 42, true])).toBe(false);
+    });
+
+    it('fails for non-array values', () => {
+      const schema = enforce.tuple(enforce.isString());
+      // @ts-expect-error - intentionally passing non-array
+      expect(schema.test('not an array')).toBe(false);
+      // @ts-expect-error - intentionally passing non-array
+      expect(schema.test({ 0: 'a' })).toBe(false);
+      // @ts-expect-error - intentionally passing null
+      expect(schema.test(null)).toBe(false);
+      // @ts-expect-error - intentionally passing undefined
+      expect(schema.test(undefined)).toBe(false);
+    });
+
+    it('passes for empty tuple schema with empty array', () => {
+      const emptyTuple = enforce.tuple();
+      expect(emptyTuple.test([])).toBe(true);
+      // @ts-expect-error - intentionally passing elements to empty tuple
+      expect(emptyTuple.test(['extra'])).toBe(false);
+    });
+  });
+
+  describe('with optional trailing elements', () => {
+    it('passes without optional element', () => {
+      const schema = enforce.tuple(
+        enforce.isString(),
+        enforce.optional(enforce.isNumber()),
+      );
+      // @ts-expect-error - runtime allows omitting optional trailing elements
+      expect(schema.test(['hello'])).toBe(true);
+    });
+
+    it('passes with optional element present', () => {
+      const schema = enforce.tuple(
+        enforce.isString(),
+        enforce.optional(enforce.isNumber()),
+      );
+      expect(schema.test(['hello', 42])).toBe(true);
+    });
+
+    it('fails when optional element has wrong type', () => {
+      const schema = enforce.tuple(
+        enforce.isString(),
+        enforce.optional(enforce.isNumber()),
+      );
+      // @ts-expect-error - intentionally passing wrong type for optional element
+      expect(schema.test(['hello', 'not a number'])).toBe(false);
+    });
+
+    it('handles multiple trailing optional elements', () => {
+      const schema = enforce.tuple(
+        enforce.isString(),
+        enforce.optional(enforce.isNumber()),
+        enforce.optional(enforce.isBoolean()),
+      );
+      // @ts-expect-error - runtime allows omitting optional trailing elements
+      expect(schema.test(['hello'])).toBe(true);
+      // @ts-expect-error - runtime allows omitting optional trailing elements
+      expect(schema.test(['hello', 42])).toBe(true);
+      expect(schema.test(['hello', 42, true])).toBe(true);
+      // @ts-expect-error - intentionally passing too many elements
+      expect(schema.test(['hello', 42, true, 'extra'])).toBe(false);
+    });
+  });
+
+  describe('nested schemas', () => {
+    it('supports shape elements', () => {
+      const schema = enforce.tuple(
+        enforce.isString(),
+        enforce.shape({ id: enforce.isNumber() }),
+      );
+
+      expect(schema.test(['test', { id: 1 }])).toBe(true);
+      // @ts-expect-error - intentionally passing wrong type for nested field
+      expect(schema.test(['test', { id: 'x' }])).toBe(false);
+    });
+
+    it('supports nested tuples', () => {
+      const schema = enforce.tuple(
+        enforce.isString(),
+        enforce.tuple(enforce.isNumber(), enforce.isNumber()),
+      );
+
+      expect(schema.test(['coords', [1, 2]])).toBe(true);
+      // @ts-expect-error - intentionally passing wrong type in nested tuple
+      expect(schema.test(['coords', [1, 'x']])).toBe(false);
+    });
+
+    it('supports isArrayOf elements', () => {
+      const schema = enforce.tuple(
+        enforce.isString(),
+        enforce.isArrayOf(enforce.isNumber()),
+      );
+
+      expect(schema.test(['tags', [1, 2, 3]])).toBe(true);
+      // @ts-expect-error - intentionally passing wrong type in array
+      expect(schema.test(['tags', [1, 'x']])).toBe(false);
+    });
+  });
+
+  describe('eager API', () => {
+    it('throws on invalid tuple', () => {
+      expect(() => {
+        enforce(['hello', 'world']).tuple(
+          enforce.isString(),
+          enforce.isNumber(),
+        );
+      }).toThrow();
+    });
+
+    it('does not throw on valid tuple', () => {
+      expect(() => {
+        enforce(['hello', 42]).tuple(enforce.isString(), enforce.isNumber());
+      }).not.toThrow();
+    });
+  });
+
+  describe('error reporting', () => {
+    it('reports index of failing element in path', () => {
+      const schema = enforce.tuple(
+        enforce.isString(),
+        enforce.isNumber(),
+        enforce.isBoolean(),
+      );
+
+      // @ts-expect-error - intentionally passing wrong type
+      const result = schema.run(['ok', 'bad', true]);
+      expect(result.pass).toBe(false);
+      expect(result.path).toBeDefined();
+      expect(result.path![0]).toBe('1');
+    });
+
+    it('reports nested error path through tuple boundary', () => {
+      const schema = enforce.tuple(
+        enforce.isString(),
+        enforce.shape({ id: enforce.isNumber() }),
+      );
+
+      // @ts-expect-error - intentionally passing wrong type for nested field
+      const result = schema.run(['ok', { id: 'bad' }]);
+      expect(result.pass).toBe(false);
+      expect(result.path).toEqual(['1', 'id']);
+    });
+  });
+
+  describe('RuleInstance methods', () => {
+    it('.test() returns boolean', () => {
+      const schema = enforce.tuple(enforce.isString(), enforce.isNumber());
+      expect(typeof schema.test(['a', 1])).toBe('boolean');
+    });
+
+    it('.run() returns RuleRunReturn', () => {
+      const schema = enforce.tuple(enforce.isString(), enforce.isNumber());
+      expect(schema.run(['a', 1]).pass).toBe(true);
+      // @ts-expect-error - intentionally passing wrong type
+      expect(schema.run(['a', 'b']).pass).toBe(false);
+    });
+
+    it('.validate() returns StandardSchema result', () => {
+      const schema = enforce.tuple(enforce.isString(), enforce.isNumber());
+      const passing = schema.validate(['a', 1]);
+      expect(passing).toHaveProperty('value');
+      expect(passing).not.toHaveProperty('issues');
+
+      // @ts-expect-error - intentionally passing wrong type
+      const failing = schema.validate(['a', 'b']);
+      expect(failing).toHaveProperty('issues');
+    });
+
+    it('.parse() returns value on success and throws on failure', () => {
+      const schema = enforce.tuple(enforce.isString(), enforce.isNumber());
+      expect(schema.parse(['a', 1])).toEqual(['a', 1]);
+      // @ts-expect-error - intentionally passing wrong type
+      expect(() => schema.parse(['a', 'b'])).toThrow();
+    });
+  });
+
+  describe('.message() override', () => {
+    it('supports custom message', () => {
+      const schema = enforce
+        .tuple(enforce.isString(), enforce.isNumber())
+        .message('Invalid coordinate');
+      const result = schema.run(['a', 'b']);
+      expect(result.pass).toBe(false);
+      expect(result.message).toBe('Invalid coordinate');
+    });
+  });
+
+  describe('type inference', () => {
+    it('infers tuple type from rules', () => {
+      const schema = enforce.tuple(
+        enforce.isString(),
+        enforce.isNumber(),
+        enforce.isBoolean(),
+      );
+
+      type Inferred = typeof schema.infer;
+      expectTypeOf<Inferred>().toEqualTypeOf<[string, number, boolean]>();
+    });
+
+    it('enforce.infer<> works with tuple', () => {
+      const schema = enforce.tuple(enforce.isString(), enforce.isNumber());
+
+      type ViaInfer = enforce.infer<typeof schema>;
+      expectTypeOf<ViaInfer>().toEqualTypeOf<[string, number]>();
+    });
+
+    it('infers tuple inside shape', () => {
+      const schema = enforce.shape({
+        name: enforce.isString(),
+        coords: enforce.tuple(enforce.isNumber(), enforce.isNumber()),
+      });
+
+      type S = typeof schema.infer;
+      expectTypeOf<S>().toEqualTypeOf<{
+        name: string;
+        coords: [number, number];
+      }>();
+    });
+
+    it('parse() return type is correctly inferred', () => {
+      const schema = enforce.tuple(enforce.isString(), enforce.isNumber());
+      // eslint-disable-next-line vitest/valid-expect
+      expectTypeOf(schema.parse).returns.toEqualTypeOf<[string, number]>();
+    });
+  });
+});

package/src/rules/schemaRules/lazy.ts

@@ -0,0 +1,48 @@
+import { ctx } from '../../enforceContext';
+import { RuleInstance } from '../../utils/RuleInstance';
+import { RuleRunReturn } from '../../utils/RuleRunReturn';
+import { addToChain } from '../genRuleChain';
+
+export type LazyRuleInstance<T> = RuleInstance<T, [T]>;
+
+/**
+ * Creates a lazy schema wrapper for recursive/self-referencing schemas.
+ * The factory function is called on first validation and cached.
+ *
+ * @param factory - A function that returns the RuleInstance to delegate to
+ * @returns A RuleInstance that defers schema resolution to validation time
+ *
+ * @example
+ * ```typescript
+ * type Category = { name: string; children: Category[] };
+ *
+ * const categorySchema = enforce.shape({
+ *   name: enforce.isString(),
+ *   children: enforce.isArrayOf(enforce.lazy(() => categorySchema)),
+ * });
+ *
+ * categorySchema.test({
+ *   name: 'Root',
+ *   children: [
+ *     { name: 'Child', children: [] },
+ *   ],
+ * }); // true
+ * ```
+ */
+export function lazy<T>(
+  factory: () => RuleInstance<T, any>,
+): LazyRuleInstance<T> {
+  let cached: RuleInstance<T, any> | null = null;
+
+  const resolve = (): RuleInstance<T, any> => {
+    if (!cached) {
+      cached = factory();
+    }
+    return cached;
+  };
+
+  return addToChain<LazyRuleInstance<T>>({}, (value: any) => {
+    const result = ctx.run({ value }, () => resolve().run(value));
+    return RuleRunReturn.create(result, value);
+  });
+}

package/src/rules/schemaRules/record.ts

@@ -0,0 +1,126 @@
+import { isObject, mapFirst } from 'vest-utils';
+
+import { ctx } from '../../enforceContext';
+import type { RuleInstance } from '../../utils/RuleInstance';
+import { RuleRunReturn } from '../../utils/RuleRunReturn';
+
+import {
+  findDangerousOwnKey,
+  ownKeys,
+  safeShallowCopy,
+} from './schemaObjectUtils';
+import type { InferShapeInput } from './schemaRulesTypes';
+
+/**
+ * Validates that an object's dynamic keys and/or values match provided rules.
+ * Like TypeScript's Record<K, V>, it checks elements against shape rules.
+ *
+ * @param value - The object to validate
+ * @param arg1 - Either the key rule (if arg2 is present) or the value rule
+ * @param arg2 - The value rule (if arg1 is the key rule)
+ * @returns RuleRunReturn indicating success or failure
+ */
+export function record<T extends Record<string, any>>(
+  value: T,
+  arg1: any,
+  arg2?: any,
+): RuleRunReturn<T> {
+  if (!isObject(value) || Array.isArray(value))
+    return RuleRunReturn.Failing(value);
+
+  const rules = parseRules(arg1, arg2);
+  const dangerousKey = findDangerousOwnKey(value);
+  if (dangerousKey)
+    return createRecordFailure(
+      value,
+      dangerousKey,
+      RuleRunReturn.Failing(value),
+    );
+
+  const parsedValue: Record<string, any> = safeShallowCopy(value);
+
+  const failingResult = mapFirst(ownKeys(value), (key, breakout) => {
+    const errorRes = evaluateRecordEntry(key, value, rules, parsedValue);
+    if (errorRes) {
+      breakout(true, errorRes);
+    }
+  });
+
+  return (
+    (failingResult as RuleRunReturn<T>) ||
+    RuleRunReturn.Passing(parsedValue as T)
+  );
+}
+
+function parseRules(arg1: any, arg2?: any) {
+  if (arg2 !== undefined) return { keyRule: arg1, valueRule: arg2 };
+  return { keyRule: undefined, valueRule: arg1 };
+}
+
+function validateKey(
+  key: string,
+  keyRule: RuleInstance<any, any>,
+): RuleRunReturn<any> {
+  return ctx.run({ value: key, set: true }, () => keyRule.run(key));
+}
+
+function evaluateRecordEntry<T extends Record<string, any>>(
+  key: string,
+  value: T,
+  rules: {
+    keyRule?: RuleInstance<any, any>;
+    valueRule: RuleInstance<any, any>;
+  },
+  parsedValue: Record<string, any>,
+): RuleRunReturn<T> | void {
+  if (rules.keyRule) {
+    const keyRes = validateKey(key, rules.keyRule);
+    if (!keyRes.pass) return createRecordFailure(value, key, keyRes);
+    if (keyRes.type !== key) {
+      delete parsedValue[key];
+      key = keyRes.type;
+    }
+  }
+
+  const valRes = ctx.run({ value: value[key], set: true, meta: { key } }, () =>
+    rules.valueRule.run(value[key]),
+  );
+
+  if (!valRes.pass) return createRecordFailure(value, key, valRes);
+  parsedValue[key] = valRes.type;
+}
+
+function createRecordFailure<T extends Record<string, any>>(
+  value: T,
+  key: string,
+  ruleRes: RuleRunReturn<any>,
+): RuleRunReturn<T> {
+  const currentPath = ruleRes.path || [];
+  const newRes = RuleRunReturn.Failing(value, ruleRes.message);
+  newRes.path = [key, ...currentPath];
+  return newRes as RuleRunReturn<T>;
+}
+
+type RecordKey<K> = [K] extends [never]
+  ? string
+  : K extends RuleInstance<any, any>
+    ? K['infer'] extends PropertyKey
+      ? K['infer']
+      : string
+    : string;
+
+type RecordInputKey<K> = [K] extends [never]
+  ? string
+  : K extends RuleInstance<any, any>
+    ? InferShapeInput<K> extends PropertyKey
+      ? InferShapeInput<K>
+      : string
+    : string;
+
+export type RecordRuleInstance<
+  K extends RuleInstance<any, any> | never,
+  V extends RuleInstance<any, any>,
+> = RuleInstance<
+  Record<RecordKey<K>, V['infer']>,
+  [Record<RecordInputKey<K>, InferShapeInput<V>>]
+>;

package/src/rules/schemaRules/schemaRules.ts

@@ -1,10 +1,17 @@
 import './schemaRulesLazyTypes';
 
-export { isArrayOf, type IsArrayOfRuleInstance } from './isArrayOf';
+export {
+  isArrayOf,
+  isArrayOf as list,
+  type IsArrayOfRuleInstance,
+} from './isArrayOf';
+export { type LazyRuleInstance } from './lazy';
 export { loose, type LooseRuleInstance } from './loose';
 export { optional, type OptionalRuleInstance } from './optional';
 export { partial, type PartialRuleInstance } from './partial';
 export { pick, type PickRuleInstance } from './pick';
 export { omit, type OmitRuleInstance } from './omit';
 export { shape, type ShapeRuleInstance } from './shape';
+export { record, type RecordRuleInstance } from './record';
+export { tuple, type TupleRuleInstance } from './tuple';
 export type { SchemaRuleLazyTypes } from './schemaRulesLazyTypes';

package/src/rules/schemaRules/schemaRulesLazyTypes.ts

@@ -8,18 +8,23 @@ import './partial';
 import './pick';
 import './omit';
 import './shape';
+import './record';
+import './tuple';
 
 import type { RuleInstance } from '../../utils/RuleInstance';
 import { MultiTypeInput, MultiTypeInputArgs } from './schemaRulesTypes';
 
 import type {
   IsArrayOfRuleInstance,
+  LazyRuleInstance,
   LooseRuleInstance,
   OptionalRuleInstance,
   PartialRuleInstance,
   PickRuleInstance,
   OmitRuleInstance,
   ShapeRuleInstance,
+  RecordRuleInstance,
+  TupleRuleInstance,
 } from './schemaRules';
 
 /**
@@ -29,6 +34,10 @@ export type SchemaRuleLazyTypes = {
   isArrayOf: <Rules extends RuleInstance<any, any>[]>(
     ...rules: Rules
   ) => IsArrayOfRuleInstance<MultiTypeInput<Rules>, MultiTypeInputArgs<Rules>>;
+  list: <Rules extends RuleInstance<any, any>[]>(
+    ...rules: Rules
+  ) => IsArrayOfRuleInstance<MultiTypeInput<Rules>, MultiTypeInputArgs<Rules>>;
+  lazy: <T>(factory: () => RuleInstance<T, any>) => LazyRuleInstance<T>;
   loose: <S extends Record<string, RuleInstance<any>>>(
     schema: S,
   ) => LooseRuleInstance<S>;
@@ -49,4 +58,16 @@ export type SchemaRuleLazyTypes = {
   shape: <S extends Record<string, RuleInstance<any>>>(
     schema: S,
   ) => ShapeRuleInstance<S>;
+  record: {
+    <V extends RuleInstance<any, any>>(
+      valueRule: V,
+    ): RecordRuleInstance<never, V>;
+    <K extends RuleInstance<string, any>, V extends RuleInstance<any, any>>(
+      keyRule: K,
+      valueRule: V,
+    ): RecordRuleInstance<K, V>;
+  };
+  tuple: <Rules extends RuleInstance<any, any>[]>(
+    ...rules: Rules
+  ) => TupleRuleInstance<Rules>;
 };

package/src/rules/schemaRules/tuple.ts

@@ -0,0 +1,157 @@
+import { greaterThan, isFunction, longerThan } from 'vest-utils';
+
+import { ctx } from '../../enforceContext';
+import type { RuleInstance } from '../../utils/RuleInstance';
+import { RuleRunReturn } from '../../utils/RuleRunReturn';
+
+/**
+ * Validates that a value is a fixed-length array (tuple) where each position
+ * matches the corresponding rule. Enforces exact length unless trailing
+ * elements use enforce.optional().
+ *
+ * Parsed values are propagated: if a rule transforms its input (e.g. toNumber),
+ * the parsed tuple returned via `.parse()` carries the transformed values.
+ *
+ * @param value - The array to validate
+ * @param rules - One RuleInstance per tuple position
+ * @returns RuleRunReturn indicating success or failure, with `.type` holding
+ *          the parsed tuple on success
+ *
+ * @example
+ * ```typescript
+ * // Eager API
+ * enforce(['hello', 42]).tuple(enforce.isString(), enforce.isNumber());
+ *
+ * // Lazy API
+ * const coordSchema = enforce.tuple(enforce.isNumber(), enforce.isNumber());
+ * coordSchema.test([40.7, -74.0]); // true
+ * coordSchema.test([40.7]);        // false — too few
+ * coordSchema.test([40.7, -74, 0]);// false — too many
+ * ```
+ */
+export function tuple(value: unknown, ...rules: any[]): RuleRunReturn<any> {
+  if (!Array.isArray(value)) return RuleRunReturn.Failing(value);
+
+  // Determine minimum required length (all rules minus trailing optionals)
+  const requiredCount = countRequired(rules);
+
+  // Reject arrays that are too short or too long
+  if (
+    greaterThan(requiredCount, value.length) ||
+    longerThan(value, rules.length)
+  ) {
+    return RuleRunReturn.Failing(value);
+  }
+
+  return validateElements(value, rules);
+}
+
+/**
+ * Counts the number of required (non-optional) leading positions by scanning
+ * backwards from the end of the rules array. Stops at the first non-optional
+ * rule, so only *trailing* optionals reduce the required count.
+ */
+function countRequired(rules: any[]): number {
+  let count = rules.length;
+  for (let i = rules.length - 1; i >= 0; i--) {
+    if (isOptionalRule(rules[i])) count = i;
+    else break;
+  }
+  return count;
+}
+
+/**
+ * Iterates over each rule position, validates the corresponding array element,
+ * and collects parsed output values. Returns early on the first failing element
+ * with an index-based error path.
+ */
+function validateElements(value: any[], rules: any[]): RuleRunReturn<any> {
+  const parsedTuple: any[] = [];
+
+  for (let i = 0; i < rules.length; i++) {
+    // Skip positions beyond the array length (only reached for trailing optionals)
+    if (isBeyondArrayEnd(value, i, rules[i])) continue;
+
+    const res = runElementRule(value[i], rules[i], i);
+
+    if (!res.pass) return elementFailure(value, res, i);
+
+    // Use the parsed value (res.type) if the rule transformed it, otherwise keep the original
+    parsedTuple.push(res.type ?? value[i]);
+  }
+
+  return RuleRunReturn.Passing(parsedTuple);
+}
+
+/**
+ * Checks whether the given index is past the array's actual length
+ * and the corresponding rule is optional, meaning it can be skipped.
+ */
+function isBeyondArrayEnd(value: any[], index: number, rule: any): boolean {
+  return index >= value.length && isOptionalRule(rule);
+}
+
+/**
+ * Runs a single element's rule within an enforce context that carries
+ * the element value and its positional index as metadata.
+ */
+function runElementRule(
+  item: any,
+  rule: any,
+  index: number,
+): RuleRunReturn<any> {
+  return ctx.run({ value: item, set: true, meta: { index } }, () =>
+    rule.run(item),
+  );
+}
+
+/**
+ * Builds a failing RuleRunReturn with an error path that includes the
+ * tuple index, prepended to any nested path from the inner rule failure.
+ * For example, a shape failure at index 1 on key "id" yields path ["1", "id"].
+ */
+function elementFailure(
+  value: any[],
+  res: RuleRunReturn<any>,
+  index: number,
+): RuleRunReturn<any> {
+  const failure = RuleRunReturn.Failing(value, res.message);
+  failure.path = [index.toString(), ...(res.path || [])];
+  return failure;
+}
+
+/**
+ * Determines whether a rule is optional by testing if it passes with undefined.
+ * This mirrors how shape/loose detect optional fields — a rule wrapping
+ * enforce.optional() will pass for undefined, while required rules will not.
+ */
+function isOptionalRule(rule: RuleInstance<any, any>): boolean {
+  if (!rule || !isFunction(rule.test)) return false;
+  return rule.test(undefined);
+}
+
+/**
+ * Maps a tuple of RuleInstances to their inferred output types.
+ * [RuleInstance<string>, RuleInstance<number>] → [string, number]
+ */
+type InferTuple<T extends RuleInstance<any, any>[]> = {
+  [K in keyof T]: T[K] extends RuleInstance<infer R, any> ? R : never;
+};
+
+/**
+ * Maps a tuple of RuleInstances to their inferred input types.
+ * Used for the Args parameter of the returned RuleInstance so that
+ * .test() and .parse() accept correctly typed tuple input.
+ */
+type InferTupleInput<T extends RuleInstance<any, any>[]> = {
+  [K in keyof T]: T[K] extends RuleInstance<any, [infer A, ...any[]]>
+    ? A
+    : never;
+};
+
+/**
+ * The RuleInstance type returned by enforce.tuple().
+ * Infers both output and input types from the provided rule tuple.
+ */
+export type TupleRuleInstance<T extends RuleInstance<any, any>[]> =
+  RuleInstance<InferTuple<T>, [InferTupleInput<T>]>;

package/types/exports/date.d.cts

@@ -1,4 +1,4 @@
-import { n as WidenFirstParam } from "../n4sTypes-ChCugpFQ.cjs";
+import { n as WidenFirstParam } from "../n4sTypes-BSTzXRsU.cjs";
 import isAfter from "validator/es/lib/isAfter";
 import isBefore from "validator/es/lib/isBefore";
 import isDate from "validator/es/lib/isDate";

package/types/exports/date.d.mts

@@ -1,4 +1,4 @@
-import { n as WidenFirstParam } from "../n4sTypes-Bb1zNxyv.mjs";
+import { n as WidenFirstParam } from "../n4sTypes-3THfSmAQ.mjs";
 import isAfter from "validator/es/lib/isAfter";
 import isBefore from "validator/es/lib/isBefore";
 import isDate from "validator/es/lib/isDate";