@warlock.js/seal 4.0.171 → 4.1.1

package/esm/rules/conditional/required-with-rules.d.mts

@@ -0,0 +1,30 @@
+import { SchemaRule } from "../../types/rule-types.mjs";
+
+//#region ../../@warlock.js/seal/src/rules/conditional/required-with-rules.d.ts
+/**
+ * Required with rule - field is required if another field is present
+ * Supports both global and sibling scope
+ */
+declare const requiredWithRule: SchemaRule<{
+  field: string;
+  scope?: "global" | "sibling";
+}>;
+/**
+ * Required with all rule - field is required if all specified fields are present
+ * Supports both global and sibling scope
+ */
+declare const requiredWithAllRule: SchemaRule<{
+  fields: string[];
+  scope?: "global" | "sibling";
+}>;
+/**
+ * Required with any rule - field is required if any of the specified fields is present
+ * Supports both global and sibling scope
+ */
+declare const requiredWithAnyRule: SchemaRule<{
+  fields: string[];
+  scope?: "global" | "sibling";
+}>;
+//#endregion
+export { requiredWithAllRule, requiredWithAnyRule, requiredWithRule };
+//# sourceMappingURL=required-with-rules.d.mts.map

package/esm/rules/conditional/required-with-rules.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"required-with-rules.d.mts","names":[],"sources":["../../../../../../../@warlock.js/seal/src/rules/conditional/required-with-rules.ts"],"mappings":";;;;;AASA;;cAAa,gBAAA,EAAkB,UAAU;EACvC,KAAA;EACA,KAAA;AAAA;;;AAAK;AAwBP;cAAa,mBAAA,EAAqB,UAAU;EAC1C,MAAA;EACA,KAAA;AAAA;;;;AAAK;cA2BM,mBAAA,EAAqB,UAAU;EAC1C,MAAA;EACA,KAAA;AAAA"}

package/esm/rules/conditional/required-with-rules.mjs

@@ -0,0 +1,66 @@
+import { getFieldValue } from "../../helpers/get-field-value.mjs";
+import { VALID_RULE, invalidRule } from "../../helpers/validation-helpers.mjs";
+import "../../helpers/index.mjs";
+import { isEmptyValue } from "../../helpers/is-empty-value.mjs";
+import { get } from "@mongez/reinforcements";
+
+//#region ../../@warlock.js/seal/src/rules/conditional/required-with-rules.ts
+/**
+* Required with rule - field is required if another field is present
+* Supports both global and sibling scope
+*/
+const requiredWithRule = {
+	name: "requiredWith",
+	description: "The field is required if another field is present",
+	sortOrder: -2,
+	requiresValue: false,
+	defaultErrorMessage: "The :input is required",
+	async validate(value, context) {
+		const fieldValue = getFieldValue(this, context);
+		if (isEmptyValue(value) && fieldValue !== void 0) {
+			this.context.translatableParams.field = this.context.options.field;
+			return invalidRule(this, context);
+		}
+		return VALID_RULE;
+	}
+};
+/**
+* Required with all rule - field is required if all specified fields are present
+* Supports both global and sibling scope
+*/
+const requiredWithAllRule = {
+	name: "requiredWithAll",
+	description: "The field is required if all specified fields are present",
+	sortOrder: -2,
+	requiresValue: false,
+	defaultErrorMessage: "The :input is required",
+	async validate(value, context) {
+		const { fields, scope = "global" } = this.context.options;
+		const source = scope === "sibling" ? context.parent : context.allValues;
+		const allPresent = fields.every((field) => get(source, field) !== void 0);
+		if (isEmptyValue(value) && allPresent) return invalidRule(this, context);
+		return VALID_RULE;
+	}
+};
+/**
+* Required with any rule - field is required if any of the specified fields is present
+* Supports both global and sibling scope
+*/
+const requiredWithAnyRule = {
+	name: "requiredWithAny",
+	description: "The field is required if any of the specified fields is present",
+	sortOrder: -2,
+	requiresValue: false,
+	defaultErrorMessage: "The :input is required",
+	async validate(value, context) {
+		const { fields, scope = "global" } = this.context.options;
+		const source = scope === "sibling" ? context.parent : context.allValues;
+		const anyPresent = fields.some((field) => get(source, field) !== void 0);
+		if (isEmptyValue(value) && anyPresent) return invalidRule(this, context);
+		return VALID_RULE;
+	}
+};
+
+//#endregion
+export { requiredWithAllRule, requiredWithAnyRule, requiredWithRule };
+//# sourceMappingURL=required-with-rules.mjs.map

package/esm/rules/conditional/required-with-rules.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"required-with-rules.mjs","names":[],"sources":["../../../../../../../@warlock.js/seal/src/rules/conditional/required-with-rules.ts"],"sourcesContent":["import { get } from \"@mongez/reinforcements\";\r\nimport { getFieldValue, invalidRule, VALID_RULE } from \"../../helpers\";\r\nimport { isEmptyValue } from \"../../helpers/is-empty-value\";\r\nimport type { SchemaRule } from \"../../types\";\r\n\r\n/**\r\n * Required with rule - field is required if another field is present\r\n * Supports both global and sibling scope\r\n */\r\nexport const requiredWithRule: SchemaRule<{\r\n  field: string;\r\n  scope?: \"global\" | \"sibling\";\r\n}> = {\r\n  name: \"requiredWith\",\r\n  description: \"The field is required if another field is present\",\r\n  sortOrder: -2,\r\n  requiresValue: false,\r\n  defaultErrorMessage: \"The :input is required\",\r\n  async validate(value: any, context) {\r\n    const fieldValue = getFieldValue(this, context);\r\n\r\n    // Field is required if the other field is present\r\n    if (isEmptyValue(value) && fieldValue !== undefined) {\r\n      this.context.translatableParams.field = this.context.options.field;\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    return VALID_RULE;\r\n  },\r\n};\r\n\r\n/**\r\n * Required with all rule - field is required if all specified fields are present\r\n * Supports both global and sibling scope\r\n */\r\nexport const requiredWithAllRule: SchemaRule<{\r\n  fields: string[];\r\n  scope?: \"global\" | \"sibling\";\r\n}> = {\r\n  name: \"requiredWithAll\",\r\n  description: \"The field is required if all specified fields are present\",\r\n  sortOrder: -2,\r\n  requiresValue: false,\r\n  defaultErrorMessage: \"The :input is required\",\r\n  async validate(value: any, context) {\r\n    const { fields, scope = \"global\" } = this.context.options;\r\n    const source = scope === \"sibling\" ? context.parent : context.allValues;\r\n\r\n    // Check if all fields are present\r\n    const allPresent = fields.every((field) => get(source, field) !== undefined);\r\n\r\n    // Field is required if all other fields are present\r\n    if (isEmptyValue(value) && allPresent) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    return VALID_RULE;\r\n  },\r\n};\r\n\r\n/**\r\n * Required with any rule - field is required if any of the specified fields is present\r\n * Supports both global and sibling scope\r\n */\r\nexport const requiredWithAnyRule: SchemaRule<{\r\n  fields: string[];\r\n  scope?: \"global\" | \"sibling\";\r\n}> = {\r\n  name: \"requiredWithAny\",\r\n  description: \"The field is required if any of the specified fields is present\",\r\n  sortOrder: -2,\r\n  requiresValue: false,\r\n  defaultErrorMessage: \"The :input is required\",\r\n  async validate(value: any, context) {\r\n    const { fields, scope = \"global\" } = this.context.options;\r\n    const source = scope === \"sibling\" ? context.parent : context.allValues;\r\n\r\n    // Check if any field is present\r\n    const anyPresent = fields.some((field) => get(source, field) !== undefined);\r\n\r\n    // Field is required if any other field is present\r\n    if (isEmptyValue(value) && anyPresent) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    return VALID_RULE;\r\n  },\r\n};\r\n"],"mappings":";;;;;;;;;;;AASA,MAAa,mBAGR;CACH,MAAM;CACN,aAAa;CACb,WAAW;CACX,eAAe;CACf,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,MAAM,aAAa,cAAc,MAAM,OAAO;EAG9C,IAAI,aAAa,KAAK,KAAK,eAAe,QAAW;GACnD,KAAK,QAAQ,mBAAmB,QAAQ,KAAK,QAAQ,QAAQ;GAC7D,OAAO,YAAY,MAAM,OAAO;EAClC;EAEA,OAAO;CACT;AACF;;;;;AAMA,MAAa,sBAGR;CACH,MAAM;CACN,aAAa;CACb,WAAW;CACX,eAAe;CACf,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,MAAM,EAAE,QAAQ,QAAQ,aAAa,KAAK,QAAQ;EAClD,MAAM,SAAS,UAAU,YAAY,QAAQ,SAAS,QAAQ;EAG9D,MAAM,aAAa,OAAO,OAAO,UAAU,IAAI,QAAQ,KAAK,MAAM,MAAS;EAG3E,IAAI,aAAa,KAAK,KAAK,YACzB,OAAO,YAAY,MAAM,OAAO;EAGlC,OAAO;CACT;AACF;;;;;AAMA,MAAa,sBAGR;CACH,MAAM;CACN,aAAa;CACb,WAAW;CACX,eAAe;CACf,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,MAAM,EAAE,QAAQ,QAAQ,aAAa,KAAK,QAAQ;EAClD,MAAM,SAAS,UAAU,YAAY,QAAQ,SAAS,QAAQ;EAG9D,MAAM,aAAa,OAAO,MAAM,UAAU,IAAI,QAAQ,KAAK,MAAM,MAAS;EAG1E,IAAI,aAAa,KAAK,KAAK,YACzB,OAAO,YAAY,MAAM,OAAO;EAGlC,OAAO;CACT;AACF"}

package/esm/rules/conditional/required-without-rules.d.mts

@@ -0,0 +1,30 @@
+import { SchemaRule } from "../../types/rule-types.mjs";
+
+//#region ../../@warlock.js/seal/src/rules/conditional/required-without-rules.d.ts
+/**
+ * Required without rule - field is required if another field is missing
+ * Supports both global and sibling scope
+ */
+declare const requiredWithoutRule: SchemaRule<{
+  field: string;
+  scope?: "global" | "sibling";
+}>;
+/**
+ * Required without all rule - field is required if all specified fields are missing
+ * Supports both global and sibling scope
+ */
+declare const requiredWithoutAllRule: SchemaRule<{
+  fields: string[];
+  scope?: "global" | "sibling";
+}>;
+/**
+ * Required without any rule - field is required if any of the specified fields is missing
+ * Supports both global and sibling scope
+ */
+declare const requiredWithoutAnyRule: SchemaRule<{
+  fields: string[];
+  scope?: "global" | "sibling";
+}>;
+//#endregion
+export { requiredWithoutAllRule, requiredWithoutAnyRule, requiredWithoutRule };
+//# sourceMappingURL=required-without-rules.d.mts.map

package/esm/rules/conditional/required-without-rules.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"required-without-rules.d.mts","names":[],"sources":["../../../../../../../@warlock.js/seal/src/rules/conditional/required-without-rules.ts"],"mappings":";;;;;AASA;;cAAa,mBAAA,EAAqB,UAAU;EAC1C,KAAA;EACA,KAAA;AAAA;;;AAAK;AAwBP;cAAa,sBAAA,EAAwB,UAAU;EAC7C,MAAA;EACA,KAAA;AAAA;;;;AAAK;cA2BM,sBAAA,EAAwB,UAAU;EAC7C,MAAA;EACA,KAAA;AAAA"}

package/esm/rules/conditional/required-without-rules.mjs

@@ -0,0 +1,66 @@
+import { getFieldValue } from "../../helpers/get-field-value.mjs";
+import { VALID_RULE, invalidRule } from "../../helpers/validation-helpers.mjs";
+import "../../helpers/index.mjs";
+import { isEmptyValue } from "../../helpers/is-empty-value.mjs";
+import { get } from "@mongez/reinforcements";
+
+//#region ../../@warlock.js/seal/src/rules/conditional/required-without-rules.ts
+/**
+* Required without rule - field is required if another field is missing
+* Supports both global and sibling scope
+*/
+const requiredWithoutRule = {
+	name: "requiredWithout",
+	description: "The field is required if another field is missing",
+	sortOrder: -2,
+	requiresValue: false,
+	defaultErrorMessage: "The :input is required",
+	async validate(value, context) {
+		const fieldValue = getFieldValue(this, context);
+		if (isEmptyValue(value) && fieldValue === void 0) {
+			this.context.translatableParams.field = this.context.options.field;
+			return invalidRule(this, context);
+		}
+		return VALID_RULE;
+	}
+};
+/**
+* Required without all rule - field is required if all specified fields are missing
+* Supports both global and sibling scope
+*/
+const requiredWithoutAllRule = {
+	name: "requiredWithoutAll",
+	description: "The field is required if all specified fields are missing",
+	sortOrder: -2,
+	requiresValue: false,
+	defaultErrorMessage: "The :input is required",
+	async validate(value, context) {
+		const { fields, scope = "global" } = this.context.options;
+		const source = scope === "sibling" ? context.parent : context.allValues;
+		const allMissing = fields.every((field) => get(source, field) === void 0);
+		if (isEmptyValue(value) && allMissing) return invalidRule(this, context);
+		return VALID_RULE;
+	}
+};
+/**
+* Required without any rule - field is required if any of the specified fields is missing
+* Supports both global and sibling scope
+*/
+const requiredWithoutAnyRule = {
+	name: "requiredWithoutAny",
+	description: "The field is required if any of the specified fields is missing",
+	sortOrder: -2,
+	requiresValue: false,
+	defaultErrorMessage: "The :input is required",
+	async validate(value, context) {
+		const { fields, scope = "global" } = this.context.options;
+		const source = scope === "sibling" ? context.parent : context.allValues;
+		const anyMissing = fields.some((field) => get(source, field) === void 0);
+		if (isEmptyValue(value) && anyMissing) return invalidRule(this, context);
+		return VALID_RULE;
+	}
+};
+
+//#endregion
+export { requiredWithoutAllRule, requiredWithoutAnyRule, requiredWithoutRule };
+//# sourceMappingURL=required-without-rules.mjs.map

package/esm/rules/conditional/required-without-rules.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"required-without-rules.mjs","names":[],"sources":["../../../../../../../@warlock.js/seal/src/rules/conditional/required-without-rules.ts"],"sourcesContent":["import { get } from \"@mongez/reinforcements\";\r\nimport { getFieldValue, invalidRule, VALID_RULE } from \"../../helpers\";\r\nimport type { SchemaRule } from \"../../types\";\r\nimport { isEmptyValue } from \"./../../helpers/is-empty-value\";\r\n\r\n/**\r\n * Required without rule - field is required if another field is missing\r\n * Supports both global and sibling scope\r\n */\r\nexport const requiredWithoutRule: SchemaRule<{\r\n  field: string;\r\n  scope?: \"global\" | \"sibling\";\r\n}> = {\r\n  name: \"requiredWithout\",\r\n  description: \"The field is required if another field is missing\",\r\n  sortOrder: -2,\r\n  requiresValue: false,\r\n  defaultErrorMessage: \"The :input is required\",\r\n  async validate(value: any, context) {\r\n    const fieldValue = getFieldValue(this, context);\r\n\r\n    // Field is required if the other field is missing\r\n    if (isEmptyValue(value) && fieldValue === undefined) {\r\n      this.context.translatableParams.field = this.context.options.field;\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    return VALID_RULE;\r\n  },\r\n};\r\n\r\n/**\r\n * Required without all rule - field is required if all specified fields are missing\r\n * Supports both global and sibling scope\r\n */\r\nexport const requiredWithoutAllRule: SchemaRule<{\r\n  fields: string[];\r\n  scope?: \"global\" | \"sibling\";\r\n}> = {\r\n  name: \"requiredWithoutAll\",\r\n  description: \"The field is required if all specified fields are missing\",\r\n  sortOrder: -2,\r\n  requiresValue: false,\r\n  defaultErrorMessage: \"The :input is required\",\r\n  async validate(value: any, context) {\r\n    const { fields, scope = \"global\" } = this.context.options;\r\n    const source = scope === \"sibling\" ? context.parent : context.allValues;\r\n\r\n    // Check if all fields are missing\r\n    const allMissing = fields.every((field) => get(source, field) === undefined);\r\n\r\n    // Field is required if all other fields are missing\r\n    if (isEmptyValue(value) && allMissing) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    return VALID_RULE;\r\n  },\r\n};\r\n\r\n/**\r\n * Required without any rule - field is required if any of the specified fields is missing\r\n * Supports both global and sibling scope\r\n */\r\nexport const requiredWithoutAnyRule: SchemaRule<{\r\n  fields: string[];\r\n  scope?: \"global\" | \"sibling\";\r\n}> = {\r\n  name: \"requiredWithoutAny\",\r\n  description: \"The field is required if any of the specified fields is missing\",\r\n  sortOrder: -2,\r\n  requiresValue: false,\r\n  defaultErrorMessage: \"The :input is required\",\r\n  async validate(value: any, context) {\r\n    const { fields, scope = \"global\" } = this.context.options;\r\n    const source = scope === \"sibling\" ? context.parent : context.allValues;\r\n\r\n    // Check if any field is missing\r\n    const anyMissing = fields.some((field) => get(source, field) === undefined);\r\n\r\n    // Field is required if any other field is missing\r\n    if (isEmptyValue(value) && anyMissing) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    return VALID_RULE;\r\n  },\r\n};\r\n"],"mappings":";;;;;;;;;;;AASA,MAAa,sBAGR;CACH,MAAM;CACN,aAAa;CACb,WAAW;CACX,eAAe;CACf,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,MAAM,aAAa,cAAc,MAAM,OAAO;EAG9C,IAAI,aAAa,KAAK,KAAK,eAAe,QAAW;GACnD,KAAK,QAAQ,mBAAmB,QAAQ,KAAK,QAAQ,QAAQ;GAC7D,OAAO,YAAY,MAAM,OAAO;EAClC;EAEA,OAAO;CACT;AACF;;;;;AAMA,MAAa,yBAGR;CACH,MAAM;CACN,aAAa;CACb,WAAW;CACX,eAAe;CACf,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,MAAM,EAAE,QAAQ,QAAQ,aAAa,KAAK,QAAQ;EAClD,MAAM,SAAS,UAAU,YAAY,QAAQ,SAAS,QAAQ;EAG9D,MAAM,aAAa,OAAO,OAAO,UAAU,IAAI,QAAQ,KAAK,MAAM,MAAS;EAG3E,IAAI,aAAa,KAAK,KAAK,YACzB,OAAO,YAAY,MAAM,OAAO;EAGlC,OAAO;CACT;AACF;;;;;AAMA,MAAa,yBAGR;CACH,MAAM;CACN,aAAa;CACb,WAAW;CACX,eAAe;CACf,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,MAAM,EAAE,QAAQ,QAAQ,aAAa,KAAK,QAAQ;EAClD,MAAM,SAAS,UAAU,YAAY,QAAQ,SAAS,QAAQ;EAG9D,MAAM,aAAa,OAAO,MAAM,UAAU,IAAI,QAAQ,KAAK,MAAM,MAAS;EAG1E,IAAI,aAAa,KAAK,KAAK,YACzB,OAAO,YAAY,MAAM,OAAO;EAGlC,OAAO;CACT;AACF"}

package/esm/rules/core/equal.d.mts

@@ -0,0 +1,12 @@
+import { SchemaRule } from "../../types/rule-types.mjs";
+
+//#region ../../@warlock.js/seal/src/rules/core/equal.d.ts
+/**
+ * Equal rule - value must be equal to a specific value
+ */
+declare const equalRule: SchemaRule<{
+  value: any;
+}>;
+//#endregion
+export { equalRule };
+//# sourceMappingURL=equal.d.mts.map

package/esm/rules/core/equal.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"equal.d.mts","names":[],"sources":["../../../../../../../@warlock.js/seal/src/rules/core/equal.ts"],"mappings":";;;;;AAMA;cAAa,SAAA,EAAW,UAAU;EAAG,KAAK;AAAA"}

package/esm/rules/core/equal.mjs

@@ -0,0 +1,22 @@
+import { VALID_RULE, invalidRule } from "../../helpers/validation-helpers.mjs";
+import "../../helpers/index.mjs";
+
+//#region ../../@warlock.js/seal/src/rules/core/equal.ts
+/**
+* Equal rule - value must be equal to a specific value
+*/
+const equalRule = {
+	name: "equal",
+	defaultErrorMessage: "The :input must be equal to :value",
+	async validate(value, context) {
+		if (value !== this.context.options.value) {
+			this.context.translatableParams.value = this.context.options.value;
+			return invalidRule(this, context);
+		}
+		return VALID_RULE;
+	}
+};
+
+//#endregion
+export { equalRule };
+//# sourceMappingURL=equal.mjs.map

package/esm/rules/core/equal.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"equal.mjs","names":[],"sources":["../../../../../../../@warlock.js/seal/src/rules/core/equal.ts"],"sourcesContent":["import { invalidRule, VALID_RULE } from \"../../helpers\";\r\nimport type { SchemaRule } from \"../../types\";\r\n\r\n/**\r\n * Equal rule - value must be equal to a specific value\r\n */\r\nexport const equalRule: SchemaRule<{ value: any }> = {\r\n  name: \"equal\",\r\n  defaultErrorMessage: \"The :input must be equal to :value\",\r\n  async validate(value: any, context) {\r\n    if (value !== this.context.options.value) {\r\n      this.context.translatableParams.value = this.context.options.value;\r\n      return invalidRule(this, context);\r\n    }\r\n    return VALID_RULE;\r\n  },\r\n};\r\n"],"mappings":";;;;;;;AAMA,MAAa,YAAwC;CACnD,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,IAAI,UAAU,KAAK,QAAQ,QAAQ,OAAO;GACxC,KAAK,QAAQ,mBAAmB,QAAQ,KAAK,QAAQ,QAAQ;GAC7D,OAAO,YAAY,MAAM,OAAO;EAClC;EACA,OAAO;CACT;AACF"}

package/esm/rules/core/forbidden.d.mts

@@ -0,0 +1,10 @@
+import { SchemaRule } from "../../types/rule-types.mjs";
+
+//#region ../../@warlock.js/seal/src/rules/core/forbidden.d.ts
+/**
+ * Forbidden rule - value must not be present
+ */
+declare const forbiddenRule: SchemaRule;
+//#endregion
+export { forbiddenRule };
+//# sourceMappingURL=forbidden.d.mts.map

package/esm/rules/core/forbidden.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"forbidden.d.mts","names":[],"sources":["../../../../../../../@warlock.js/seal/src/rules/core/forbidden.ts"],"mappings":";;;;;AAOA;cAAa,aAAA,EAAe,UAS3B"}

package/esm/rules/core/forbidden.mjs

@@ -0,0 +1,20 @@
+import { VALID_RULE, invalidRule } from "../../helpers/validation-helpers.mjs";
+import "../../helpers/index.mjs";
+import { isEmptyValue } from "../../helpers/is-empty-value.mjs";
+
+//#region ../../@warlock.js/seal/src/rules/core/forbidden.ts
+/**
+* Forbidden rule - value must not be present
+*/
+const forbiddenRule = {
+	name: "forbidden",
+	defaultErrorMessage: "The :input is forbidden",
+	async validate(value, context) {
+		if (!isEmptyValue(value)) return invalidRule(this, context);
+		return VALID_RULE;
+	}
+};
+
+//#endregion
+export { forbiddenRule };
+//# sourceMappingURL=forbidden.mjs.map

package/esm/rules/core/forbidden.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"forbidden.mjs","names":[],"sources":["../../../../../../../@warlock.js/seal/src/rules/core/forbidden.ts"],"sourcesContent":["import { invalidRule, VALID_RULE } from \"../../helpers\";\r\nimport { isEmptyValue } from \"../../helpers/is-empty-value\";\r\nimport type { SchemaRule } from \"../../types\";\r\n\r\n/**\r\n * Forbidden rule - value must not be present\r\n */\r\nexport const forbiddenRule: SchemaRule = {\r\n  name: \"forbidden\",\r\n  defaultErrorMessage: \"The :input is forbidden\",\r\n  async validate(value: any, context) {\r\n    if (!isEmptyValue(value)) {\r\n      return invalidRule(this, context);\r\n    }\r\n    return VALID_RULE;\r\n  },\r\n};\r\n"],"mappings":";;;;;;;;AAOA,MAAa,gBAA4B;CACvC,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,IAAI,CAAC,aAAa,KAAK,GACrB,OAAO,YAAY,MAAM,OAAO;EAElC,OAAO;CACT;AACF"}

package/esm/rules/core/index.mjs

@@ -0,0 +1,7 @@
+import { presentRule, requiredRule } from "./required.mjs";
+import { equalRule } from "./equal.mjs";
+import { forbiddenRule } from "./forbidden.mjs";
+import { unionRule } from "./union.mjs";
+import { whenRule } from "./when.mjs";
+
+export {  };

package/esm/rules/core/required.d.mts

@@ -0,0 +1,15 @@
+import { SchemaRule } from "../../types/rule-types.mjs";
+
+//#region ../../@warlock.js/seal/src/rules/core/required.d.ts
+/**
+ * Required rule - value must be present and not empty
+ */
+declare const requiredRule: SchemaRule;
+/**
+ * Present rule - key must exist in the data, but value can be anything
+ * (empty string, null are all valid as long as the key exists)
+ */
+declare const presentRule: SchemaRule;
+//#endregion
+export { presentRule, requiredRule };
+//# sourceMappingURL=required.d.mts.map

package/esm/rules/core/required.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"required.d.mts","names":[],"sources":["../../../../../../../@warlock.js/seal/src/rules/core/required.ts"],"mappings":";;;;;AAOA;cAAa,YAAA,EAAc,UAW1B;;;AAAA;AAMD;cAAa,WAAA,EAAa,UAYzB"}

package/esm/rules/core/required.mjs

@@ -0,0 +1,36 @@
+import { VALID_RULE, invalidRule } from "../../helpers/validation-helpers.mjs";
+import "../../helpers/index.mjs";
+import { isEmptyValue } from "../../helpers/is-empty-value.mjs";
+
+//#region ../../@warlock.js/seal/src/rules/core/required.ts
+/**
+* Required rule - value must be present and not empty
+*/
+const requiredRule = {
+	name: "required",
+	defaultErrorMessage: "The :input is required",
+	requiresValue: false,
+	sortOrder: -2,
+	async validate(value, context) {
+		if (isEmptyValue(value)) return invalidRule(this, context);
+		return VALID_RULE;
+	}
+};
+/**
+* Present rule - key must exist in the data, but value can be anything
+* (empty string, null are all valid as long as the key exists)
+*/
+const presentRule = {
+	name: "present",
+	defaultErrorMessage: "The :input field is required",
+	requiresValue: false,
+	sortOrder: -2,
+	async validate(value, context) {
+		if (value === void 0) return invalidRule(this, context);
+		return VALID_RULE;
+	}
+};
+
+//#endregion
+export { presentRule, requiredRule };
+//# sourceMappingURL=required.mjs.map

package/esm/rules/core/required.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"required.mjs","names":[],"sources":["../../../../../../../@warlock.js/seal/src/rules/core/required.ts"],"sourcesContent":["import { invalidRule, VALID_RULE } from \"../../helpers\";\r\nimport { isEmptyValue } from \"../../helpers/is-empty-value\";\r\nimport type { SchemaRule } from \"../../types\";\r\n\r\n/**\r\n * Required rule - value must be present and not empty\r\n */\r\nexport const requiredRule: SchemaRule = {\r\n  name: \"required\",\r\n  defaultErrorMessage: \"The :input is required\",\r\n  requiresValue: false,\r\n  sortOrder: -2,\r\n  async validate(value: any, context) {\r\n    if (isEmptyValue(value)) {\r\n      return invalidRule(this, context);\r\n    }\r\n    return VALID_RULE;\r\n  },\r\n};\r\n\r\n/**\r\n * Present rule - key must exist in the data, but value can be anything\r\n * (empty string, null are all valid as long as the key exists)\r\n */\r\nexport const presentRule: SchemaRule = {\r\n  name: \"present\",\r\n  defaultErrorMessage: \"The :input field is required\",\r\n  requiresValue: false,\r\n  sortOrder: -2,\r\n  async validate(value: any, context) {\r\n    if (value === undefined) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    return VALID_RULE;\r\n  },\r\n};\r\n"],"mappings":";;;;;;;;AAOA,MAAa,eAA2B;CACtC,MAAM;CACN,qBAAqB;CACrB,eAAe;CACf,WAAW;CACX,MAAM,SAAS,OAAY,SAAS;EAClC,IAAI,aAAa,KAAK,GACpB,OAAO,YAAY,MAAM,OAAO;EAElC,OAAO;CACT;AACF;;;;;AAMA,MAAa,cAA0B;CACrC,MAAM;CACN,qBAAqB;CACrB,eAAe;CACf,WAAW;CACX,MAAM,SAAS,OAAY,SAAS;EAClC,IAAI,UAAU,QACZ,OAAO,YAAY,MAAM,OAAO;EAGlC,OAAO;CACT;AACF"}

package/esm/rules/core/union.d.mts

@@ -0,0 +1,13 @@
+import { SchemaRule } from "../../types/rule-types.mjs";
+import { BaseValidator } from "../../validators/base-validator.mjs";
+
+//#region ../../@warlock.js/seal/src/rules/core/union.d.ts
+/**
+ * Union rule - value must match at least one of the provided validators
+ */
+declare const unionRule: SchemaRule<{
+  validators: BaseValidator[];
+}>;
+//#endregion
+export { unionRule };
+//# sourceMappingURL=union.d.mts.map

package/esm/rules/core/union.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"union.d.mts","names":[],"sources":["../../../../../../../@warlock.js/seal/src/rules/core/union.ts"],"mappings":";;;;;;AAOA;cAAa,SAAA,EAAW,UAAU;EAAG,UAAA,EAAY,aAAA;AAAA"}

package/esm/rules/core/union.mjs

@@ -0,0 +1,30 @@
+import { VALID_RULE, invalidRule } from "../../helpers/validation-helpers.mjs";
+import "../../helpers/index.mjs";
+
+//#region ../../@warlock.js/seal/src/rules/core/union.ts
+/**
+* Union rule - value must match at least one of the provided validators
+*/
+const unionRule = {
+	name: "union",
+	defaultErrorMessage: "Value must match one of the allowed types",
+	async validate(value, context) {
+		const validators = this.context.options.validators;
+		const firstErrorOnly = context.configurations?.firstErrorOnly ?? true;
+		const allErrors = [];
+		for (const validator of validators) {
+			if (!validator.matchesType(value)) continue;
+			const result = await validator.validate(value, context);
+			if (result.isValid) return VALID_RULE;
+			const errorMsg = result.errors?.[0]?.error || "Validation failed";
+			allErrors.push(errorMsg);
+			if (firstErrorOnly) break;
+		}
+		if (allErrors.length > 0) this.context.errorMessage = firstErrorOnly ? allErrors[0] : allErrors.join("; ");
+		return invalidRule(this, context);
+	}
+};
+
+//#endregion
+export { unionRule };
+//# sourceMappingURL=union.mjs.map

package/esm/rules/core/union.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"union.mjs","names":[],"sources":["../../../../../../../@warlock.js/seal/src/rules/core/union.ts"],"sourcesContent":["import { invalidRule, VALID_RULE } from \"../../helpers\";\r\nimport type { SchemaRule } from \"../../types\";\r\nimport type { BaseValidator } from \"../../validators/base-validator\";\r\n\r\n/**\r\n * Union rule - value must match at least one of the provided validators\r\n */\r\nexport const unionRule: SchemaRule<{ validators: BaseValidator[] }> = {\r\n  name: \"union\",\r\n  defaultErrorMessage: \"Value must match one of the allowed types\",\r\n  async validate(value: any, context) {\r\n    const validators = this.context.options.validators;\r\n    const firstErrorOnly = context.configurations?.firstErrorOnly ?? true;\r\n    const allErrors: string[] = [];\r\n\r\n    // Try each validator\r\n    for (const validator of validators) {\r\n      // Skip if type doesn't match (optimization)\r\n      if (!validator.matchesType(value)) {\r\n        continue;\r\n      }\r\n\r\n      // Type matches - validate\r\n      const result = await validator.validate(value, context);\r\n\r\n      if (result.isValid) {\r\n        // Success! Validator matched and validated\r\n        return VALID_RULE;\r\n      }\r\n\r\n      // Failed - collect error message\r\n      const errorMsg = result.errors?.[0]?.error || \"Validation failed\";\r\n      allErrors.push(errorMsg);\r\n\r\n      // If firstErrorOnly, stop after first failed validator\r\n      if (firstErrorOnly) {\r\n        break;\r\n      }\r\n    }\r\n\r\n    // All failed or no validator matched the type\r\n    if (allErrors.length > 0) {\r\n      // At least one validator matched type but failed validation\r\n      this.context.errorMessage = firstErrorOnly\r\n        ? allErrors[0]\r\n        : allErrors.join(\"; \");\r\n    }\r\n\r\n    return invalidRule(this, context);\r\n  },\r\n};\r\n"],"mappings":";;;;;;;AAOA,MAAa,YAAyD;CACpE,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,MAAM,aAAa,KAAK,QAAQ,QAAQ;EACxC,MAAM,iBAAiB,QAAQ,gBAAgB,kBAAkB;EACjE,MAAM,YAAsB,CAAC;EAG7B,KAAK,MAAM,aAAa,YAAY;GAElC,IAAI,CAAC,UAAU,YAAY,KAAK,GAC9B;GAIF,MAAM,SAAS,MAAM,UAAU,SAAS,OAAO,OAAO;GAEtD,IAAI,OAAO,SAET,OAAO;GAIT,MAAM,WAAW,OAAO,SAAS,IAAI,SAAS;GAC9C,UAAU,KAAK,QAAQ;GAGvB,IAAI,gBACF;EAEJ;EAGA,IAAI,UAAU,SAAS,GAErB,KAAK,QAAQ,eAAe,iBACxB,UAAU,KACV,UAAU,KAAK,IAAI;EAGzB,OAAO,YAAY,MAAM,OAAO;CAClC;AACF"}

package/esm/rules/core/when.d.mts

@@ -0,0 +1,11 @@
+import { SchemaRule } from "../../types/rule-types.mjs";
+import { WhenRuleOptions } from "../../types/conditional-types.mjs";
+
+//#region ../../@warlock.js/seal/src/rules/core/when.d.ts
+/**
+ * When rule - conditional validation based on another field value
+ */
+declare const whenRule: SchemaRule<WhenRuleOptions>;
+//#endregion
+export { whenRule };
+//# sourceMappingURL=when.d.mts.map

package/esm/rules/core/when.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"when.d.mts","names":[],"sources":["../../../../../../../@warlock.js/seal/src/rules/core/when.ts"],"mappings":";;;;;;;cAOa,QAAA,EAAU,UAAU,CAAC,eAAA"}

package/esm/rules/core/when.mjs

@@ -0,0 +1,36 @@
+import { VALID_RULE, invalidRule } from "../../helpers/validation-helpers.mjs";
+import "../../helpers/index.mjs";
+import { get } from "@mongez/reinforcements";
+
+//#region ../../@warlock.js/seal/src/rules/core/when.ts
+/**
+* When rule - conditional validation based on another field value
+*/
+const whenRule = {
+	name: "when",
+	description: "Apply conditional validation based on another field value",
+	async validate(value, context) {
+		const fieldToCheck = this.context.options.field;
+		const conditions = this.context.options.is;
+		const otherwise = this.context.options.otherwise;
+		const fieldValue = (this.context.options.scope || "global") === "global" ? get(context.allValues, fieldToCheck) : get(context.parent, fieldToCheck);
+		const fieldValueKey = String(fieldValue);
+		if (conditions[fieldValueKey]) {
+			const result = await conditions[fieldValueKey].validate(value, context);
+			if (result.isValid) return VALID_RULE;
+			this.context.errorMessage = result.errors?.[0]?.error || "Validation failed";
+			return invalidRule(this, context);
+		}
+		if (otherwise) {
+			const result = await otherwise.validate(value, context);
+			if (result.isValid) return VALID_RULE;
+			this.context.errorMessage = result.errors?.[0]?.error || "Validation failed";
+			return invalidRule(this, context);
+		}
+		return VALID_RULE;
+	}
+};
+
+//#endregion
+export { whenRule };
+//# sourceMappingURL=when.mjs.map

package/esm/rules/core/when.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"when.mjs","names":[],"sources":["../../../../../../../@warlock.js/seal/src/rules/core/when.ts"],"sourcesContent":["import { get } from \"@mongez/reinforcements\";\r\nimport { invalidRule, VALID_RULE } from \"../../helpers\";\r\nimport type { SchemaRule, WhenRuleOptions } from \"../../types\";\r\n\r\n/**\r\n * When rule - conditional validation based on another field value\r\n */\r\nexport const whenRule: SchemaRule<WhenRuleOptions> = {\r\n  name: \"when\",\r\n  description: \"Apply conditional validation based on another field value\",\r\n  async validate(value: any, context) {\r\n    const fieldToCheck = this.context.options.field;\r\n    const conditions = this.context.options.is;\r\n    const otherwise = this.context.options.otherwise;\r\n    const scope = this.context.options.scope || \"global\";\r\n\r\n    const fieldValue =\r\n      scope === \"global\"\r\n        ? get(context.allValues, fieldToCheck)\r\n        : get(context.parent, fieldToCheck);\r\n\r\n    // Convert field value to string for key lookup\r\n    // This handles boolean, number, and string field values\r\n    const fieldValueKey = String(fieldValue);\r\n\r\n    if (conditions[fieldValueKey]) {\r\n      const result = await conditions[fieldValueKey].validate(value, context);\r\n      if (result.isValid) {\r\n        return VALID_RULE;\r\n      }\r\n\r\n      // Safe error access\r\n      this.context.errorMessage =\r\n        result.errors?.[0]?.error || \"Validation failed\";\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    if (otherwise) {\r\n      const result = await otherwise.validate(value, context);\r\n\r\n      if (result.isValid) {\r\n        return VALID_RULE;\r\n      }\r\n\r\n      // Safe error access\r\n      this.context.errorMessage =\r\n        result.errors?.[0]?.error || \"Validation failed\";\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    return VALID_RULE;\r\n  },\r\n};\r\n"],"mappings":";;;;;;;;AAOA,MAAa,WAAwC;CACnD,MAAM;CACN,aAAa;CACb,MAAM,SAAS,OAAY,SAAS;EAClC,MAAM,eAAe,KAAK,QAAQ,QAAQ;EAC1C,MAAM,aAAa,KAAK,QAAQ,QAAQ;EACxC,MAAM,YAAY,KAAK,QAAQ,QAAQ;EAGvC,MAAM,cAFQ,KAAK,QAAQ,QAAQ,SAAS,cAGhC,WACN,IAAI,QAAQ,WAAW,YAAY,IACnC,IAAI,QAAQ,QAAQ,YAAY;EAItC,MAAM,gBAAgB,OAAO,UAAU;EAEvC,IAAI,WAAW,gBAAgB;GAC7B,MAAM,SAAS,MAAM,WAAW,eAAe,SAAS,OAAO,OAAO;GACtE,IAAI,OAAO,SACT,OAAO;GAIT,KAAK,QAAQ,eACX,OAAO,SAAS,IAAI,SAAS;GAC/B,OAAO,YAAY,MAAM,OAAO;EAClC;EAEA,IAAI,WAAW;GACb,MAAM,SAAS,MAAM,UAAU,SAAS,OAAO,OAAO;GAEtD,IAAI,OAAO,SACT,OAAO;GAIT,KAAK,QAAQ,eACX,OAAO,SAAS,IAAI,SAAS;GAC/B,OAAO,YAAY,MAAM,OAAO;EAClC;EAEA,OAAO;CACT;AACF"}

package/esm/rules/date/date-comparison-rules.d.mts

@@ -0,0 +1,29 @@
+import { SchemaRule } from "../../types/rule-types.mjs";
+
+//#region ../../@warlock.js/seal/src/rules/date/date-comparison-rules.d.ts
+/**
+ * Between dates rule - date must be between start and end dates
+ */
+declare const betweenDatesRule: SchemaRule<{
+  startDate: Date;
+  endDate: Date;
+}>;
+/**
+ * Today rule - date must be exactly today
+ */
+declare const todayRule: SchemaRule;
+/**
+ * Past rule - date must be in the past
+ */
+declare const pastRule: SchemaRule;
+/**
+ * Future rule - date must be in the future
+ */
+declare const futureRule: SchemaRule;
+/**
+ * After today rule - date must be after today (not including today)
+ */
+declare const afterTodayRule: SchemaRule;
+//#endregion
+export { afterTodayRule, betweenDatesRule, futureRule, pastRule, todayRule };
+//# sourceMappingURL=date-comparison-rules.d.mts.map

package/esm/rules/date/date-comparison-rules.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"date-comparison-rules.d.mts","names":[],"sources":["../../../../../../../@warlock.js/seal/src/rules/date/date-comparison-rules.ts"],"mappings":";;;;;AAMA;cAAa,gBAAA,EAAkB,UAAA;EAC7B,SAAA,EAAW,IAAA;EACX,OAAA,EAAS,IAAA;AAAA;;;;cAqBE,SAAA,EAAW,UAcvB;;;;cAKY,QAAA,EAAU,UAYtB;;AApDc;AAqBf;cAoCa,UAAA,EAAY,UAYxB;;;AAlCA;cAuCY,cAAA,EAAgB,UAc5B"}

package/esm/rules/date/date-comparison-rules.mjs

@@ -0,0 +1,78 @@
+import { VALID_RULE, invalidRule } from "../../helpers/validation-helpers.mjs";
+import "../../helpers/index.mjs";
+
+//#region ../../@warlock.js/seal/src/rules/date/date-comparison-rules.ts
+/**
+* Between dates rule - date must be between start and end dates
+*/
+const betweenDatesRule = {
+	name: "betweenDates",
+	defaultErrorMessage: "The :input must be between :startDate and :endDate",
+	async validate(value, context) {
+		const { startDate, endDate } = this.context.options;
+		const inputDate = new Date(value);
+		if (inputDate >= startDate && inputDate <= endDate) {
+			this.context.translationParams.startDate = startDate.toISOString();
+			this.context.translationParams.endDate = endDate.toISOString();
+			return VALID_RULE;
+		}
+		return invalidRule(this, context);
+	}
+};
+/**
+* Today rule - date must be exactly today
+*/
+const todayRule = {
+	name: "today",
+	defaultErrorMessage: "The :input must be today",
+	async validate(value, context) {
+		const today = /* @__PURE__ */ new Date();
+		today.setHours(0, 0, 0, 0);
+		const inputDate = new Date(value);
+		inputDate.setHours(0, 0, 0, 0);
+		if (inputDate.getTime() === today.getTime()) return VALID_RULE;
+		return invalidRule(this, context);
+	}
+};
+/**
+* Past rule - date must be in the past
+*/
+const pastRule = {
+	name: "past",
+	defaultErrorMessage: "The :input must be in the past",
+	async validate(value, context) {
+		const now = /* @__PURE__ */ new Date();
+		if (new Date(value) < now) return VALID_RULE;
+		return invalidRule(this, context);
+	}
+};
+/**
+* Future rule - date must be in the future
+*/
+const futureRule = {
+	name: "future",
+	defaultErrorMessage: "The :input must be in the future",
+	async validate(value, context) {
+		if (value > /* @__PURE__ */ new Date()) return VALID_RULE;
+		return invalidRule(this, context);
+	}
+};
+/**
+* After today rule - date must be after today (not including today)
+*/
+const afterTodayRule = {
+	name: "afterToday",
+	defaultErrorMessage: "The :input must be after today",
+	async validate(value, context) {
+		const today = /* @__PURE__ */ new Date();
+		today.setHours(0, 0, 0, 0);
+		const inputDate = new Date(value);
+		inputDate.setHours(0, 0, 0, 0);
+		if (inputDate > today) return VALID_RULE;
+		return invalidRule(this, context);
+	}
+};
+
+//#endregion
+export { afterTodayRule, betweenDatesRule, futureRule, pastRule, todayRule };
+//# sourceMappingURL=date-comparison-rules.mjs.map

package/esm/rules/date/date-comparison-rules.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"date-comparison-rules.mjs","names":[],"sources":["../../../../../../../@warlock.js/seal/src/rules/date/date-comparison-rules.ts"],"sourcesContent":["import { invalidRule, VALID_RULE } from \"../../helpers\";\r\nimport type { SchemaRule } from \"../../types\";\r\n\r\n/**\r\n * Between dates rule - date must be between start and end dates\r\n */\r\nexport const betweenDatesRule: SchemaRule<{\r\n  startDate: Date;\r\n  endDate: Date;\r\n}> = {\r\n  name: \"betweenDates\",\r\n  defaultErrorMessage: \"The :input must be between :startDate and :endDate\",\r\n  async validate(value: Date, context) {\r\n    const { startDate, endDate } = this.context.options;\r\n    const inputDate = new Date(value);\r\n\r\n    if (inputDate >= startDate && inputDate <= endDate) {\r\n      this.context.translationParams.startDate = startDate.toISOString();\r\n      this.context.translationParams.endDate = endDate.toISOString();\r\n      return VALID_RULE;\r\n    }\r\n\r\n    return invalidRule(this, context);\r\n  },\r\n};\r\n\r\n/**\r\n * Today rule - date must be exactly today\r\n */\r\nexport const todayRule: SchemaRule = {\r\n  name: \"today\",\r\n  defaultErrorMessage: \"The :input must be today\",\r\n  async validate(value: Date, context) {\r\n    const today = new Date();\r\n    today.setHours(0, 0, 0, 0);\r\n    const inputDate = new Date(value);\r\n    inputDate.setHours(0, 0, 0, 0);\r\n\r\n    if (inputDate.getTime() === today.getTime()) {\r\n      return VALID_RULE;\r\n    }\r\n    return invalidRule(this, context);\r\n  },\r\n};\r\n\r\n/**\r\n * Past rule - date must be in the past\r\n */\r\nexport const pastRule: SchemaRule = {\r\n  name: \"past\",\r\n  defaultErrorMessage: \"The :input must be in the past\",\r\n  async validate(value: Date, context) {\r\n    const now = new Date();\r\n    const inputDate = new Date(value);\r\n\r\n    if (inputDate < now) {\r\n      return VALID_RULE;\r\n    }\r\n    return invalidRule(this, context);\r\n  },\r\n};\r\n\r\n/**\r\n * Future rule - date must be in the future\r\n */\r\nexport const futureRule: SchemaRule = {\r\n  name: \"future\",\r\n  defaultErrorMessage: \"The :input must be in the future\",\r\n  async validate(value: Date, context) {\r\n    const now = new Date();\r\n\r\n    if (value > now) {\r\n      return VALID_RULE;\r\n    }\r\n\r\n    return invalidRule(this, context);\r\n  },\r\n};\r\n\r\n/**\r\n * After today rule - date must be after today (not including today)\r\n */\r\nexport const afterTodayRule: SchemaRule = {\r\n  name: \"afterToday\",\r\n  defaultErrorMessage: \"The :input must be after today\",\r\n  async validate(value: Date, context) {\r\n    const today = new Date();\r\n    today.setHours(0, 0, 0, 0);\r\n    const inputDate = new Date(value);\r\n    inputDate.setHours(0, 0, 0, 0);\r\n\r\n    if (inputDate > today) {\r\n      return VALID_RULE;\r\n    }\r\n    return invalidRule(this, context);\r\n  },\r\n};\r\n"],"mappings":";;;;;;;AAMA,MAAa,mBAGR;CACH,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAa,SAAS;EACnC,MAAM,EAAE,WAAW,YAAY,KAAK,QAAQ;EAC5C,MAAM,YAAY,IAAI,KAAK,KAAK;EAEhC,IAAI,aAAa,aAAa,aAAa,SAAS;GAClD,KAAK,QAAQ,kBAAkB,YAAY,UAAU,YAAY;GACjE,KAAK,QAAQ,kBAAkB,UAAU,QAAQ,YAAY;GAC7D,OAAO;EACT;EAEA,OAAO,YAAY,MAAM,OAAO;CAClC;AACF;;;;AAKA,MAAa,YAAwB;CACnC,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAa,SAAS;EACnC,MAAM,wBAAQ,IAAI,KAAK;EACvB,MAAM,SAAS,GAAG,GAAG,GAAG,CAAC;EACzB,MAAM,YAAY,IAAI,KAAK,KAAK;EAChC,UAAU,SAAS,GAAG,GAAG,GAAG,CAAC;EAE7B,IAAI,UAAU,QAAQ,MAAM,MAAM,QAAQ,GACxC,OAAO;EAET,OAAO,YAAY,MAAM,OAAO;CAClC;AACF;;;;AAKA,MAAa,WAAuB;CAClC,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAa,SAAS;EACnC,MAAM,sBAAM,IAAI,KAAK;EAGrB,IAAI,IAFkB,KAAK,KAEf,IAAI,KACd,OAAO;EAET,OAAO,YAAY,MAAM,OAAO;CAClC;AACF;;;;AAKA,MAAa,aAAyB;CACpC,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAa,SAAS;EAGnC,IAAI,wBAAQ,IAFI,KAEF,GACZ,OAAO;EAGT,OAAO,YAAY,MAAM,OAAO;CAClC;AACF;;;;AAKA,MAAa,iBAA6B;CACxC,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAa,SAAS;EACnC,MAAM,wBAAQ,IAAI,KAAK;EACvB,MAAM,SAAS,GAAG,GAAG,GAAG,CAAC;EACzB,MAAM,YAAY,IAAI,KAAK,KAAK;EAChC,UAAU,SAAS,GAAG,GAAG,GAAG,CAAC;EAE7B,IAAI,YAAY,OACd,OAAO;EAET,OAAO,YAAY,MAAM,OAAO;CAClC;AACF"}