n4s 5.0.1 → 5.0.2

package/types/compose.d.ts

@@ -1,49 +1,32 @@
-type DropFirst<T extends unknown[]> = T extends [
-    unknown,
-    ...infer U
-] ? U : never;
-type TStringable = string | ((...args: any[]) => string);
-type TRuleReturn = boolean | {
+import { CB, Stringable, DynamicValue, DropFirst, BlankValue } from "vest-utils";
+type RuleReturn = boolean | {
     pass: boolean;
-    message?: TStringable;
+    message?: Stringable;
 };
-type TRuleDetailedResult = {
+type RuleDetailedResult = {
     pass: boolean;
     message?: string;
 };
-type TArgs = any[];
-type TBaseRules = typeof baseRules;
-type KBaseRules = keyof TBaseRules;
-declare function condition(value: any, callback: (value: any) => TRuleReturn): TRuleReturn;
+type Args = any[];
+type BaseRules = typeof baseRules;
+type KBaseRules = keyof BaseRules;
+declare function condition(value: any, callback: (value: any) => RuleReturn): RuleReturn;
 declare function endsWith(value: string, arg1: string): boolean;
 declare function equals(value: unknown, arg1: unknown): boolean;
-declare function greaterThan(value: number | string, gt: number | string): boolean;
 declare function greaterThanOrEquals(value: string | number, gte: string | number): boolean;
 declare function inside(value: unknown, arg1: string | unknown[]): boolean;
-// The module is named "isArrayValue" since it
-// is conflicting with a nested npm dependency.
-// We may need to revisit this in the future.
-declare function isArray(value: unknown): value is Array<unknown>;
 declare function isBetween(value: number | string, min: number | string, max: number | string): boolean;
-declare function isBlank(value: unknown): boolean;
-declare function isBoolean(value: unknown): value is boolean;
-declare function isEmpty(value: unknown): boolean;
+declare function isBlank(value: unknown): value is BlankValue;
+declare function isKeyOf(key: string | symbol | number, obj: any): boolean;
 declare function isNaN(value: unknown): boolean;
 declare function isNegative(value: number | string): boolean;
-declare function isNull(value: unknown): value is null;
-declare function isNullish(value: any): value is null | undefined;
 declare function isNumber(value: unknown): value is number;
-declare function isNumeric(value: string | number): boolean;
-declare function isStringValue(v: unknown): v is string;
 declare function isTruthy(value: unknown): boolean;
-declare function isUndefined(value?: unknown): boolean;
-declare function lengthEquals(value: string | unknown[], arg1: string | number): boolean;
+declare function isValueOf(value: any, objectToCheck: any): boolean;
 declare function lessThan(value: string | number, lt: string | number): boolean;
 declare function lessThanOrEquals(value: string | number, lte: string | number): boolean;
-declare function longerThan(value: string | unknown[], arg1: string | number): boolean;
 declare function longerThanOrEquals(value: string | unknown[], arg1: string | number): boolean;
 declare function matches(value: string, regex: RegExp | string): boolean;
-declare function numberEquals(value: string | number, eq: string | number): boolean;
 declare function shorterThan(value: string | unknown[], arg1: string | number): boolean;
 declare function shorterThanOrEquals(value: string | unknown[], arg1: string | number): boolean;
 declare function startsWith(value: string, arg1: string): boolean;
@@ -53,18 +36,19 @@ declare const baseRules: {
     doesNotStartWith: (value: string, arg1: string) => boolean;
     endsWith: typeof endsWith;
     equals: typeof equals;
-    greaterThan: typeof greaterThan;
+    greaterThan: typeof import("vest-utils").greaterThan;
     greaterThanOrEquals: typeof greaterThanOrEquals;
-    gt: typeof greaterThan;
+    gt: typeof import("vest-utils").greaterThan;
     gte: typeof greaterThanOrEquals;
     inside: typeof inside;
-    isArray: typeof isArray;
+    isArray: typeof import("vest-utils").isArray;
     isBetween: typeof isBetween;
     isBlank: typeof isBlank;
-    isBoolean: typeof isBoolean;
-    isEmpty: typeof isEmpty;
+    isBoolean: typeof import("vest-utils").isBoolean;
+    isEmpty: typeof import("vest-utils").isEmpty;
     isEven: (value: any) => boolean;
     isFalsy: (value: unknown) => boolean;
+    isKeyOf: typeof isKeyOf;
     isNaN: typeof isNaN;
     isNegative: typeof isNegative;
     isNotArray: (value: unknown) => boolean;
@@ -72,6 +56,7 @@ declare const baseRules: {
     isNotBlank: (value: unknown) => boolean;
     isNotBoolean: (value: unknown) => boolean;
     isNotEmpty: (value: unknown) => boolean;
+    isNotKeyOf: (key: string | number | symbol, obj: any) => boolean;
     isNotNaN: (value: unknown) => boolean;
     isNotNull: (value: unknown) => boolean;
     isNotNullish: (value: any) => boolean;
@@ -79,20 +64,22 @@ declare const baseRules: {
     isNotNumeric: (value: string | number) => boolean;
     isNotString: (v: unknown) => boolean;
     isNotUndefined: (value?: unknown) => boolean;
-    isNull: typeof isNull;
-    isNullish: typeof isNullish;
+    isNotValueOf: (value: any, objectToCheck: any) => boolean;
+    isNull: typeof import("vest-utils").isNull;
+    isNullish: typeof import("vest-utils").isNullish;
     isNumber: typeof isNumber;
-    isNumeric: typeof isNumeric;
+    isNumeric: typeof import("vest-utils").isNumeric;
     isOdd: (value: any) => boolean;
-    isPositive: (value: string | number) => boolean;
-    isString: typeof isStringValue;
+    isPositive: typeof import("vest-utils").isPositive;
+    isString: typeof import("vest-utils").isStringValue;
     isTruthy: typeof isTruthy;
-    isUndefined: typeof isUndefined;
-    lengthEquals: typeof lengthEquals;
+    isUndefined: typeof import("vest-utils").isUndefined;
+    isValueOf: typeof isValueOf;
+    lengthEquals: typeof import("vest-utils").lengthEquals;
     lengthNotEquals: (value: string | unknown[], arg1: string | number) => boolean;
     lessThan: typeof lessThan;
     lessThanOrEquals: typeof lessThanOrEquals;
-    longerThan: typeof longerThan;
+    longerThan: typeof import("vest-utils").longerThan;
     longerThanOrEquals: typeof longerThanOrEquals;
     lt: typeof lessThan;
     lte: typeof lessThanOrEquals;
@@ -100,35 +87,39 @@ declare const baseRules: {
     notEquals: (value: unknown, arg1: unknown) => boolean;
     notInside: (value: unknown, arg1: string | unknown[]) => boolean;
     notMatches: (value: string, regex: string | RegExp) => boolean;
-    numberEquals: typeof numberEquals;
+    numberEquals: typeof import("vest-utils").numberEquals;
     numberNotEquals: (value: string | number, eq: string | number) => boolean;
     shorterThan: typeof shorterThan;
     shorterThanOrEquals: typeof shorterThanOrEquals;
     startsWith: typeof startsWith;
 };
-type TRules<E = Record<string, unknown>> = n4s.EnforceCustomMatchers<TRules<E> & E> & Record<string, (...args: TArgs) => TRules<E> & E> & {
-    [P in KBaseRules]: (...args: DropFirst<Parameters<TBaseRules[P]>> | TArgs) => TRules<E> & E;
+type Rules<E = Record<string, unknown>> = n4s.EnforceCustomMatchers<Rules<E> & E> & Record<string, (...args: Args) => Rules<E> & E> & {
+    [P in KBaseRules]: (...args: DropFirst<Parameters<BaseRules[P]>> | Args) => Rules<E> & E;
 };
 /* eslint-disable @typescript-eslint/no-namespace, @typescript-eslint/no-empty-interface */
 declare global {
     namespace n4s {
-        interface IRules<E> extends TRules<E> {
+        interface IRules<E> extends Rules<E> {
         }
     }
 }
-type TLazyRules = n4s.IRules<TLazyRuleMethods>;
-type TLazy = TLazyRules & TLazyRuleMethods & 
+type LazyRules = n4s.IRules<LazyRuleMethods>;
+type Lazy = LazyRules & LazyRuleMethods & 
 // This is a "catch all" hack to make TS happy while not
 // losing type hints
-Record<string, (...args: any[]) => any>;
-type TLazyRuleMethods = TLazyRuleRunners & {
-    message: (message: TLazyMessage) => TLazy;
+Record<string, CB>;
+type LazyRuleMethods = LazyRuleRunners & {
+    message: (message: LazyMessage) => Lazy;
 };
-type TLazyRuleRunners = {
+type LazyRuleRunners = {
     test: (value: unknown) => boolean;
-    run: (value: unknown) => TRuleDetailedResult;
+    run: (value: unknown) => RuleDetailedResult;
 };
-type TComposeResult = TLazyRuleRunners & ((value: any) => void);
-type TLazyMessage = string | ((value: unknown, originalMessage?: TStringable) => string);
-declare function compose(...composites: TLazyRuleRunners[]): TComposeResult;
+type ComposeResult = LazyRuleRunners & ((value: any) => void);
+type LazyMessage = DynamicValue<string, [
+    value: unknown,
+    originalMessage?: Stringable
+]>;
+declare function compose(...composites: LazyRuleRunners[]): ComposeResult;
 export { compose as default };
+//# sourceMappingURL=compose.d.ts.map

package/types/compose.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compose.d.ts","sourceRoot":"","sources":["../src/exports/compose.ts","../src/runtime/enforceContext.ts","../src/lib/ruleReturn.ts","../src/rules/endsWith.ts","../src/rules/equals.ts","../src/rules/greaterThanOrEquals.ts","../src/rules/inside.ts","../src/rules/lessThan.ts","../src/rules/lessThanOrEquals.ts","../src/rules/isBetween.ts","../src/rules/isBlank.ts","../src/rules/isBoolean.ts","../src/rules/isEven.ts","../src/rules/isKeyOf.ts","../src/rules/isNaN.ts","../src/rules/isNegative.ts","../src/rules/isNumber.ts","../src/rules/isOdd.ts","../src/rules/isString.ts","../src/rules/isTruthy.ts","../src/rules/isValueOf.ts","../src/rules/longerThanOrEquals.ts","../src/rules/matches.ts","../src/rules/ruleCondition.ts","../src/rules/shorterThan.ts","../src/rules/shorterThanOrEquals.ts","../src/rules/startsWith.ts","../src/runtime/rules.ts","../src/runtime/runtimeRules.ts","../src/lib/transformResult.ts","../src/runtime/genEnforceLazy.ts","../src/lib/runLazyRule.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AASA,iBAAwB,OAAO,CAC7B,GAAG,UAAU,EAAE,eAAe,EAAE,GAC/B,aAAa,CAoCf"}

package/types/compounds.d.ts

@@ -1,49 +1,33 @@
-type DropFirst<T extends unknown[]> = T extends [
-    unknown,
-    ...infer U
-] ? U : never;
-type TStringable = string | ((...args: any[]) => string);
-type TRuleReturn = boolean | {
+import { CB, DropFirst, Stringable, DynamicValue, BlankValue } from "vest-utils";
+type EnforceCustomMatcher<F extends CB, R> = (...args: DropFirst<Parameters<F>>) => R;
+type RuleReturn = boolean | {
     pass: boolean;
-    message?: TStringable;
+    message?: Stringable;
 };
-type TRuleDetailedResult = {
+type RuleDetailedResult = {
     pass: boolean;
     message?: string;
 };
-type TArgs = any[];
-type TBaseRules = typeof baseRules;
-type KBaseRules = keyof TBaseRules;
-declare function condition(value: any, callback: (value: any) => TRuleReturn): TRuleReturn;
+type Args = any[];
+type BaseRules = typeof baseRules;
+type KBaseRules = keyof BaseRules;
+declare function condition(value: any, callback: (value: any) => RuleReturn): RuleReturn;
 declare function endsWith(value: string, arg1: string): boolean;
 declare function equals(value: unknown, arg1: unknown): boolean;
-declare function greaterThan(value: number | string, gt: number | string): boolean;
 declare function greaterThanOrEquals(value: string | number, gte: string | number): boolean;
 declare function inside(value: unknown, arg1: string | unknown[]): boolean;
-// The module is named "isArrayValue" since it
-// is conflicting with a nested npm dependency.
-// We may need to revisit this in the future.
-declare function isArray(value: unknown): value is Array<unknown>;
 declare function isBetween(value: number | string, min: number | string, max: number | string): boolean;
-declare function isBlank(value: unknown): boolean;
-declare function isBoolean(value: unknown): value is boolean;
-declare function isEmpty(value: unknown): boolean;
+declare function isBlank(value: unknown): value is BlankValue;
+declare function isKeyOf(key: string | symbol | number, obj: any): boolean;
 declare function isNaN(value: unknown): boolean;
 declare function isNegative(value: number | string): boolean;
-declare function isNull(value: unknown): value is null;
-declare function isNullish(value: any): value is null | undefined;
 declare function isNumber(value: unknown): value is number;
-declare function isNumeric(value: string | number): boolean;
-declare function isStringValue(v: unknown): v is string;
 declare function isTruthy(value: unknown): boolean;
-declare function isUndefined(value?: unknown): boolean;
-declare function lengthEquals(value: string | unknown[], arg1: string | number): boolean;
+declare function isValueOf(value: any, objectToCheck: any): boolean;
 declare function lessThan(value: string | number, lt: string | number): boolean;
 declare function lessThanOrEquals(value: string | number, lte: string | number): boolean;
-declare function longerThan(value: string | unknown[], arg1: string | number): boolean;
 declare function longerThanOrEquals(value: string | unknown[], arg1: string | number): boolean;
 declare function matches(value: string, regex: RegExp | string): boolean;
-declare function numberEquals(value: string | number, eq: string | number): boolean;
 declare function shorterThan(value: string | unknown[], arg1: string | number): boolean;
 declare function shorterThanOrEquals(value: string | unknown[], arg1: string | number): boolean;
 declare function startsWith(value: string, arg1: string): boolean;
@@ -53,18 +37,19 @@ declare const baseRules: {
     doesNotStartWith: (value: string, arg1: string) => boolean;
     endsWith: typeof endsWith;
     equals: typeof equals;
-    greaterThan: typeof greaterThan;
+    greaterThan: typeof import("vest-utils").greaterThan;
     greaterThanOrEquals: typeof greaterThanOrEquals;
-    gt: typeof greaterThan;
+    gt: typeof import("vest-utils").greaterThan;
     gte: typeof greaterThanOrEquals;
     inside: typeof inside;
-    isArray: typeof isArray;
+    isArray: typeof import("vest-utils").isArray;
     isBetween: typeof isBetween;
     isBlank: typeof isBlank;
-    isBoolean: typeof isBoolean;
-    isEmpty: typeof isEmpty;
+    isBoolean: typeof import("vest-utils").isBoolean;
+    isEmpty: typeof import("vest-utils").isEmpty;
     isEven: (value: any) => boolean;
     isFalsy: (value: unknown) => boolean;
+    isKeyOf: typeof isKeyOf;
     isNaN: typeof isNaN;
     isNegative: typeof isNegative;
     isNotArray: (value: unknown) => boolean;
@@ -72,6 +57,7 @@ declare const baseRules: {
     isNotBlank: (value: unknown) => boolean;
     isNotBoolean: (value: unknown) => boolean;
     isNotEmpty: (value: unknown) => boolean;
+    isNotKeyOf: (key: string | number | symbol, obj: any) => boolean;
     isNotNaN: (value: unknown) => boolean;
     isNotNull: (value: unknown) => boolean;
     isNotNullish: (value: any) => boolean;
@@ -79,20 +65,22 @@ declare const baseRules: {
     isNotNumeric: (value: string | number) => boolean;
     isNotString: (v: unknown) => boolean;
     isNotUndefined: (value?: unknown) => boolean;
-    isNull: typeof isNull;
-    isNullish: typeof isNullish;
+    isNotValueOf: (value: any, objectToCheck: any) => boolean;
+    isNull: typeof import("vest-utils").isNull;
+    isNullish: typeof import("vest-utils").isNullish;
     isNumber: typeof isNumber;
-    isNumeric: typeof isNumeric;
+    isNumeric: typeof import("vest-utils").isNumeric;
     isOdd: (value: any) => boolean;
-    isPositive: (value: string | number) => boolean;
-    isString: typeof isStringValue;
+    isPositive: typeof import("vest-utils").isPositive;
+    isString: typeof import("vest-utils").isStringValue;
     isTruthy: typeof isTruthy;
-    isUndefined: typeof isUndefined;
-    lengthEquals: typeof lengthEquals;
+    isUndefined: typeof import("vest-utils").isUndefined;
+    isValueOf: typeof isValueOf;
+    lengthEquals: typeof import("vest-utils").lengthEquals;
     lengthNotEquals: (value: string | unknown[], arg1: string | number) => boolean;
     lessThan: typeof lessThan;
     lessThanOrEquals: typeof lessThanOrEquals;
-    longerThan: typeof longerThan;
+    longerThan: typeof import("vest-utils").longerThan;
     longerThanOrEquals: typeof longerThanOrEquals;
     lt: typeof lessThan;
     lte: typeof lessThanOrEquals;
@@ -100,47 +88,47 @@ declare const baseRules: {
     notEquals: (value: unknown, arg1: unknown) => boolean;
     notInside: (value: unknown, arg1: string | unknown[]) => boolean;
     notMatches: (value: string, regex: string | RegExp) => boolean;
-    numberEquals: typeof numberEquals;
+    numberEquals: typeof import("vest-utils").numberEquals;
     numberNotEquals: (value: string | number, eq: string | number) => boolean;
     shorterThan: typeof shorterThan;
     shorterThanOrEquals: typeof shorterThanOrEquals;
     startsWith: typeof startsWith;
 };
-type TRules<E = Record<string, unknown>> = n4s.EnforceCustomMatchers<TRules<E> & E> & Record<string, (...args: TArgs) => TRules<E> & E> & {
-    [P in KBaseRules]: (...args: DropFirst<Parameters<TBaseRules[P]>> | TArgs) => TRules<E> & E;
+type Rules<E = Record<string, unknown>> = n4s.EnforceCustomMatchers<Rules<E> & E> & Record<string, (...args: Args) => Rules<E> & E> & {
+    [P in KBaseRules]: (...args: DropFirst<Parameters<BaseRules[P]>> | Args) => Rules<E> & E;
 };
 /* eslint-disable @typescript-eslint/no-namespace, @typescript-eslint/no-empty-interface */
 declare global {
     namespace n4s {
-        interface IRules<E> extends TRules<E> {
+        interface IRules<E> extends Rules<E> {
         }
     }
 }
-type TLazyRules = n4s.IRules<TLazyRuleMethods>;
-type TLazy = TLazyRules & TLazyRuleMethods & 
+type LazyRules = n4s.IRules<LazyRuleMethods>;
+type Lazy = LazyRules & LazyRuleMethods & 
 // This is a "catch all" hack to make TS happy while not
 // losing type hints
-Record<string, (...args: any[]) => any>;
-type TLazyRuleMethods = TLazyRuleRunners & {
-    message: (message: TLazyMessage) => TLazy;
+Record<string, CB>;
+type LazyRuleMethods = LazyRuleRunners & {
+    message: (message: LazyMessage) => Lazy;
 };
-type TLazyRuleRunners = {
+type LazyRuleRunners = {
     test: (value: unknown) => boolean;
-    run: (value: unknown) => TRuleDetailedResult;
+    run: (value: unknown) => RuleDetailedResult;
 };
-type TLazyMessage = string | ((value: unknown, originalMessage?: TStringable) => string);
-declare function allOf(value: unknown, ...rules: TLazy[]): TRuleDetailedResult;
-declare function anyOf(value: unknown, ...rules: TLazy[]): TRuleDetailedResult;
-declare function noneOf(value: unknown, ...rules: TLazy[]): TRuleDetailedResult;
-declare function oneOf(value: unknown, ...rules: TLazy[]): TRuleDetailedResult;
+type LazyMessage = DynamicValue<string, [
+    value: unknown,
+    originalMessage?: Stringable
+]>;
+type EnforceCompoundRule = (value: unknown, ...rules: Lazy[]) => RuleDetailedResult;
 declare global {
     namespace n4s {
         interface EnforceCustomMatchers<R> {
-            allOf: (...args: DropFirst<Parameters<typeof allOf>>) => R;
-            anyOf: (...args: DropFirst<Parameters<typeof anyOf>>) => R;
-            noneOf: (...args: DropFirst<Parameters<typeof noneOf>>) => R;
-            oneOf: (...args: DropFirst<Parameters<typeof oneOf>>) => R;
+            allOf: EnforceCustomMatcher<EnforceCompoundRule, R>;
+            anyOf: EnforceCustomMatcher<EnforceCompoundRule, R>;
+            noneOf: EnforceCustomMatcher<EnforceCompoundRule, R>;
+            oneOf: EnforceCustomMatcher<EnforceCompoundRule, R>;
         }
     }
 }
-export {};
+//# sourceMappingURL=compounds.d.ts.map

package/types/compounds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compounds.d.ts","sourceRoot":"","sources":["../src/exports/compounds.ts","../src/runtime/enforceContext.ts","../src/lib/ruleReturn.ts","../src/rules/endsWith.ts","../src/rules/equals.ts","../src/rules/greaterThanOrEquals.ts","../src/rules/inside.ts","../src/rules/lessThan.ts","../src/rules/lessThanOrEquals.ts","../src/rules/isBetween.ts","../src/rules/isBlank.ts","../src/rules/isBoolean.ts","../src/rules/isEven.ts","../src/rules/isKeyOf.ts","../src/rules/isNaN.ts","../src/rules/isNegative.ts","../src/rules/isNumber.ts","../src/rules/isOdd.ts","../src/rules/isString.ts","../src/rules/isTruthy.ts","../src/rules/isValueOf.ts","../src/rules/longerThanOrEquals.ts","../src/rules/matches.ts","../src/rules/ruleCondition.ts","../src/rules/shorterThan.ts","../src/rules/shorterThanOrEquals.ts","../src/rules/startsWith.ts","../src/runtime/rules.ts","../src/runtime/runtimeRules.ts","../src/lib/transformResult.ts","../src/runtime/genEnforceLazy.ts","../src/lib/runLazyRule.ts","../src/plugins/compounds/allOf.ts","../src/plugins/compounds/anyOf.ts","../src/lib/enforceUtilityTypes.ts","../src/plugins/compounds/noneOf.ts","../src/plugins/compounds/oneOf.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAYA,KAAK,mBAAmB,GAAG,CACzB,KAAK,EAAE,OAAO,EACd,GAAG,KAAK,EAAE,IAAI,EAAE,KACb,kBAAkB,CAAC;AAGxB,QAAQ,MAAM,CAAC;IACb,UAAU,GAAG,CAAC;QACZ,UAAU,qBAAqB,CAAC,CAAC;YAC/B,KAAK,EAAE,oBAAoB,CAAC,mBAAmB,EAAE,CAAC,CAAC,CAAC;YACpD,KAAK,EAAE,oBAAoB,CAAC,mBAAmB,EAAE,CAAC,CAAC,CAAC;YACpD,MAAM,EAAE,oBAAoB,CAAC,mBAAmB,EAAE,CAAC,CAAC,CAAC;YACrD,KAAK,EAAE,oBAAoB,CAAC,mBAAmB,EAAE,CAAC,CAAC,CAAC;SACrD;KACF;CACF"}

package/types/date.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="validator" />
+import isAfter from 'validator/es/lib/isAfter';
+import isBefore from 'validator/es/lib/isBefore';
+import isDate from 'validator/es/lib/isDate';
+import isISO8601 from 'validator/es/lib/isISO8601';
+import { CB, DropFirst } from "vest-utils";
+type EnforceCustomMatcher<F extends CB, R> = (...args: DropFirst<Parameters<F>>) => R;
+declare global {
+    namespace n4s {
+        interface EnforceCustomMatchers<R> {
+            isAfter: EnforceCustomMatcher<typeof isAfter, R>;
+            isBefore: EnforceCustomMatcher<typeof isBefore, R>;
+            isDate: EnforceCustomMatcher<typeof isDate, R>;
+            isISO8601: EnforceCustomMatcher<typeof isISO8601, R>;
+        }
+    }
+}
+//# sourceMappingURL=date.d.ts.map

package/types/date.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"date.d.ts","sourceRoot":"","sources":["../src/exports/date.ts","../src/lib/enforceUtilityTypes.ts"],"names":[],"mappings":";AACA,OAAO,OAAO,MAAM,0BAA0B,CAAC;AAC/C,OAAO,QAAQ,MAAM,2BAA2B,CAAC;AACjD,OAAO,MAAM,MAAM,yBAAyB,CAAC;AAC7C,OAAO,SAAS,MAAM,4BAA4B,CAAC;;;AAOnD,QAAQ,MAAM,CAAC;IACb,UAAU,GAAG,CAAC;QACZ,UAAU,qBAAqB,CAAC,CAAC;YAC/B,OAAO,EAAE,oBAAoB,CAAC,OAAO,OAAO,EAAE,CAAC,CAAC,CAAC;YACjD,QAAQ,EAAE,oBAAoB,CAAC,OAAO,QAAQ,EAAE,CAAC,CAAC,CAAC;YACnD,MAAM,EAAE,oBAAoB,CAAC,OAAO,MAAM,EAAE,CAAC,CAAC,CAAC;YAC/C,SAAS,EAAE,oBAAoB,CAAC,OAAO,SAAS,EAAE,CAAC,CAAC,CAAC;SACtD;KACF;CACF"}

package/types/email.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="validator" />
+import isEmail from 'validator/es/lib/isEmail';
+import { CB, DropFirst } from "vest-utils";
+type EnforceCustomMatcher<F extends CB, R> = (...args: DropFirst<Parameters<F>>) => R;
+declare global {
+    namespace n4s {
+        interface EnforceCustomMatchers<R> {
+            isEmail: EnforceCustomMatcher<typeof isEmail, R>;
+        }
+    }
+}
+//# sourceMappingURL=email.d.ts.map

package/types/email.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"email.d.ts","sourceRoot":"","sources":["../src/exports/email.ts","../src/lib/enforceUtilityTypes.ts"],"names":[],"mappings":";AACA,OAAO,OAAO,MAAM,0BAA0B,CAAC;;;AAO/C,QAAQ,MAAM,CAAC;IACb,UAAU,GAAG,CAAC;QACZ,UAAU,qBAAqB,CAAC,CAAC;YAC/B,OAAO,EAAE,oBAAoB,CAAC,OAAO,OAAO,EAAE,CAAC,CAAC,CAAC;SAClD;KACF;CACF"}

package/types/isURL.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="validator" />
+import isURL from 'validator/es/lib/isURL';
+import { CB, DropFirst } from "vest-utils";
+type EnforceCustomMatcher<F extends CB, R> = (...args: DropFirst<Parameters<F>>) => R;
+declare global {
+    namespace n4s {
+        interface EnforceCustomMatchers<R> {
+            isURL: EnforceCustomMatcher<typeof isURL, R>;
+        }
+    }
+}
+//# sourceMappingURL=isURL.d.ts.map

package/types/isURL.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isURL.d.ts","sourceRoot":"","sources":["../src/exports/isURL.ts","../src/lib/enforceUtilityTypes.ts"],"names":[],"mappings":";AACA,OAAO,KAAK,MAAM,wBAAwB,CAAC;;;AAO3C,QAAQ,MAAM,CAAC;IACb,UAAU,GAAG,CAAC;QACZ,UAAU,qBAAqB,CAAC,CAAC;YAC/B,KAAK,EAAE,oBAAoB,CAAC,OAAO,KAAK,EAAE,CAAC,CAAC,CAAC;SAC9C;KACF;CACF"}