@warlock.js/seal 4.0.174 → 4.1.1

package/esm/validators/methods/required-methods.d.mts

@@ -0,0 +1,193 @@
+import { SchemaContext } from "../../types/context-types.mjs";
+
+//#region ../../@warlock.js/seal/src/validators/methods/required-methods.d.ts
+declare module "../base-validator" {
+  interface BaseValidator {
+    /**
+     * This value must be present and has a value
+     */
+    required(errorMessage?: string): this;
+    /**
+     * Value must be present but not necessarily has a value
+     */
+    present(errorMessage?: string): this;
+    /**
+     * Mark the field as optional, so pass it if it has no value or has a value
+     * Because this is the default behavior, this method is just syntactic sugar
+     */
+    optional(): this & {
+      isOptional: true;
+    };
+    /**
+     * Sugar for `.optional().nullable()` — the field may be absent OR null.
+     *
+     * Brands the return type with both `{ isOptional: true }` and `{ isNullable: true }`
+     * so `Infer<>` produces `{ field?: T | null }`.
+     *
+     * @example
+     * v.string().nullish()
+     * // type: string | null | undefined
+     * //   absent  → key omitted
+     * //   null    → null
+     * //   "x"     → "x"
+     */
+    nullish(): this & {
+      isOptional: true;
+      isNullable: true;
+    };
+    /**
+     * Value is required if another field exists
+     */
+    requiredWith(field: string, errorMessage?: string): this;
+    /**
+     * Value is required if another sibling field exists
+     */
+    requiredWithSibling(field: string, errorMessage?: string): this;
+    /**
+     * Value is required if another field is missing
+     */
+    requiredWithout(field: string, errorMessage?: string): this;
+    /**
+     * Value is required if another sibling field is missing
+     */
+    requiredWithoutSibling(field: string, errorMessage?: string): this;
+    /**
+     * Value is required if another field equals a specific value
+     */
+    requiredIf(field: string, value: any, errorMessage?: string): this;
+    /**
+     * Value is required if another sibling field equals a specific value
+     */
+    requiredIfSibling(field: string, value: any, errorMessage?: string): this;
+    /**
+     * Value is required unless another field equals a specific value
+     */
+    requiredUnless(field: string, value: any, errorMessage?: string): this;
+    /**
+     * Value is required unless another sibling field equals a specific value
+     */
+    requiredUnlessSibling(field: string, value: any, errorMessage?: string): this;
+    /**
+     * Value is required if another field is empty
+     */
+    requiredIfEmpty(field: string, errorMessage?: string): this;
+    /**
+     * Value is required if another sibling field is empty
+     */
+    requiredIfEmptySibling(field: string, errorMessage?: string): this;
+    /**
+     * Value is required if another field is not empty
+     */
+    requiredIfNotEmpty(field: string, errorMessage?: string): this;
+    /**
+     * Value is required if another sibling field is not empty
+     */
+    requiredIfNotEmptySibling(field: string, errorMessage?: string): this;
+    /**
+     * Value is required if ALL specified fields are empty
+     */
+    requiredIfAllEmpty(fields: string[], errorMessage?: string): this;
+    /**
+     * Value is required if ALL specified sibling fields are empty
+     */
+    requiredIfAllEmptySiblings(fields: string[], errorMessage?: string): this;
+    /**
+     * Value is required if ANY of the specified fields is empty
+     */
+    requiredIfAnyEmpty(fields: string[], errorMessage?: string): this;
+    /**
+     * Value is required if ANY of the specified sibling fields is empty
+     */
+    requiredIfAnyEmptySiblings(fields: string[], errorMessage?: string): this;
+    /**
+     * Value is required if ALL specified fields are NOT empty
+     */
+    requiredIfAllNotEmpty(fields: string[], errorMessage?: string): this;
+    /**
+     * Value is required if ALL specified sibling fields are NOT empty
+     */
+    requiredIfAllNotEmptySiblings(fields: string[], errorMessage?: string): this;
+    /**
+     * Value is required if ANY of the specified fields is NOT empty
+     */
+    requiredIfAnyNotEmpty(fields: string[], errorMessage?: string): this;
+    /**
+     * Value is required if ANY of the specified sibling fields is NOT empty
+     */
+    requiredIfAnyNotEmptySiblings(fields: string[], errorMessage?: string): this;
+    /**
+     * Value is required if another field's value is in the given array
+     */
+    requiredIfIn(field: string, values: any[], errorMessage?: string): this;
+    /**
+     * Value is required if another sibling field's value is in the given array
+     */
+    requiredIfInSibling(field: string, values: any[], errorMessage?: string): this;
+    /**
+     * Value is required if another field's value is NOT in the given array
+     */
+    requiredIfNotIn(field: string, values: any[], errorMessage?: string): this;
+    /**
+     * Value is required if another sibling field's value is NOT in the given array
+     */
+    requiredIfNotInSibling(field: string, values: any[], errorMessage?: string): this;
+    /**
+     * Value is required if all specified fields exist
+     */
+    requiredWithAll(fields: string[], errorMessage?: string): this;
+    /**
+     * Value is required if all specified sibling fields exist
+     */
+    requiredWithAllSiblings(fields: string[], errorMessage?: string): this;
+    /**
+     * Value is required if all specified fields are missing
+     */
+    requiredWithoutAll(fields: string[], errorMessage?: string): this;
+    /**
+     * Value is required if all specified sibling fields are missing
+     */
+    requiredWithoutAllSiblings(fields: string[], errorMessage?: string): this;
+    /**
+     * Value is required if any of the specified fields exists
+     */
+    requiredWithAny(fields: string[], errorMessage?: string): this;
+    /**
+     * Value is required if any of the specified sibling fields exists
+     */
+    requiredWithAnySiblings(fields: string[], errorMessage?: string): this;
+    /**
+     * Value is required if any of the specified fields is missing
+     */
+    requiredWithoutAny(fields: string[], errorMessage?: string): this;
+    /**
+     * Value is required if any of the specified sibling fields is missing
+     */
+    requiredWithoutAnySiblings(fields: string[], errorMessage?: string): this;
+    /**
+     * Make this field required based on a custom callback.
+     *
+     * The callback receives only the `SchemaContext` (not the value),
+     * because "required" is about surrounding conditions, not the field itself.
+     * Return `true` if the field should be required.
+     *
+     * @param callback - Receives SchemaContext, returns boolean
+     * @param errorMessage - Optional custom error message
+     *
+     * @example
+     * ```ts
+     * // Required when email notification is enabled
+     * v.string().requiredWhen((context) => {
+     *   return context.allData.notificationMethod === 'email';
+     * })
+     *
+     * // Required based on multiple conditions
+     * v.string().requiredWhen((context) => {
+     *   const { role, department } = context.allData;
+     *   return role === 'manager' && department === 'finance';
+     * })
+     * ```
+     */
+    requiredWhen(callback: (context: SchemaContext) => boolean | Promise<boolean>, errorMessage?: string): this;
+  }
+} //# sourceMappingURL=required-methods.d.ts.map
+//# sourceMappingURL=required-methods.d.mts.map

package/esm/validators/methods/required-methods.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"required-methods.d.mts","names":[],"sources":["../../../../../../../@warlock.js/seal/src/validators/methods/required-methods.ts"],"mappings":";;;;YA4BY,aAAA;IAJqC;;;IAQ7C,QAAA,CAAS,YAAA;IAJD;;;IASR,OAAA,CAAQ,YAAA;IAAA;;;;IAMR,QAAA;MAAqB,UAAA;IAAA;IAoBR;;;;;;;;;;;;;IALb,OAAA;MAAoB,UAAA;MAAkB,UAAA;IAAA;IA8BL;;;IAzBjC,YAAA,CAAa,KAAA,UAAe,YAAA;IA8BE;;;IAzB9B,mBAAA,CAAoB,KAAA,UAAe,YAAA;IA8BE;;;IAzBrC,eAAA,CAAgB,KAAA,UAAe,YAAA;IA8BA;;;IAzB/B,sBAAA,CAAuB,KAAA,UAAe,YAAA;IAmCtC;;;IA9BA,UAAA,CAAW,KAAA,UAAe,KAAA,OAAY,YAAA;IAmCZ;;;IA9B1B,iBAAA,CAAkB,KAAA,UAAe,KAAA,OAAY,YAAA;IAmCR;;;IA9BrC,cAAA,CAAe,KAAA,UAAe,KAAA,OAAY,YAAA;IAwC1C;;;IAnCA,qBAAA,CAAsB,KAAA,UAAe,KAAA,OAAY,YAAA;IAwCtB;;;IAnC3B,eAAA,CAAgB,KAAA,UAAe,YAAA;IAwCS;;;IAnCxC,sBAAA,CAAuB,KAAA,UAAe,YAAA;IA6CtC;;;IAxCA,kBAAA,CAAmB,KAAA,UAAe,YAAA;IA6CJ;;;IAxC9B,yBAAA,CAA0B,KAAA,UAAe,YAAA;IA6Cb;;;IAxC5B,kBAAA,CAAmB,MAAA,YAAkB,YAAA;IA6CF;;;IAxCnC,0BAAA,CAA2B,MAAA,YAAkB,YAAA;IA6Cd;;;IAxC/B,kBAAA,CAAmB,MAAA,YAAkB,YAAA;IA6CC;;;IAxCtC,0BAAA,CAA2B,MAAA,YAAkB,YAAA;IA6CX;;;IAxClC,qBAAA,CAAsB,MAAA,YAAkB,YAAA;IAkDxC;;;IA7CA,6BAAA,CAA8B,MAAA,YAAkB,YAAA;IAkDrB;;;IA7C3B,qBAAA,CAAsB,MAAA,YAAkB,YAAA;IAkDN;;;IA7ClC,6BAAA,CAA8B,MAAA,YAAkB,YAAA;IAuDhD;;;IAlDA,YAAA,CAAa,KAAA,UAAe,MAAA,SAAe,YAAA;IAuDhB;;;IAlD3B,mBAAA,CAAoB,KAAA,UAAe,MAAA,SAAe,YAAA;IA6ErC;;;IAxEb,eAAA,CAAgB,KAAA,UAAe,MAAA,SAAe,YAAA;IAyEvB;;AAAA;IApEvB,sBAAA,CAAuB,KAAA,UAAe,MAAA,SAAe,YAAA;;;;IAKrD,eAAA,CAAgB,MAAA,YAAkB,YAAA;;;;IAKlC,uBAAA,CAAwB,MAAA,YAAkB,YAAA;;;;IAK1C,kBAAA,CAAmB,MAAA,YAAkB,YAAA;;;;IAKrC,0BAAA,CAA2B,MAAA,YAAkB,YAAA;;;;IAK7C,eAAA,CAAgB,MAAA,YAAkB,YAAA;;;;IAKlC,uBAAA,CAAwB,MAAA,YAAkB,YAAA;;;;IAK1C,kBAAA,CAAmB,MAAA,YAAkB,YAAA;;;;IAKrC,0BAAA,CAA2B,MAAA,YAAkB,YAAA;;;;;;;;;;;;;;;;;;;;;;;;;IA0B7C,YAAA,CACE,QAAA,GAAW,OAAA,EAAS,aAAA,eAA4B,OAAO,WACvD,YAAA;EAAA;AAAA"}

package/esm/validators/methods/required-methods.mjs

@@ -0,0 +1,347 @@
+import { presentRule, requiredRule } from "../../rules/core/required.mjs";
+import { BaseValidator } from "../base-validator.mjs";
+import { requiredIfAllEmptyRule, requiredIfAllNotEmptyRule, requiredIfAnyEmptyRule, requiredIfAnyNotEmptyRule, requiredIfEmptyRule, requiredIfInRule, requiredIfNotEmptyRule, requiredIfNotInRule, requiredIfRule } from "../../rules/conditional/required-if-rules.mjs";
+import { requiredUnlessRule } from "../../rules/conditional/required-unless-rules.mjs";
+import { requiredWhenRule } from "../../rules/conditional/required-when-rule.mjs";
+import { requiredWithAllRule, requiredWithAnyRule, requiredWithRule } from "../../rules/conditional/required-with-rules.mjs";
+import { requiredWithoutAllRule, requiredWithoutAnyRule, requiredWithoutRule } from "../../rules/conditional/required-without-rules.mjs";
+
+//#region ../../@warlock.js/seal/src/validators/methods/required-methods.ts
+/**
+* This value must be present and has a value
+*/
+BaseValidator.prototype.required = function(errorMessage) {
+	return this.setRequiredRule(requiredRule, errorMessage);
+};
+/**
+* Value must be present but not necessarily has a value
+*/
+BaseValidator.prototype.present = function(errorMessage) {
+	return this.setRequiredRule(presentRule, errorMessage);
+};
+/**
+* Mark the field as optional — it may be absent or empty without validation errors.
+* Clears any previously set required rule.
+*
+* The return type is branded with `{ isOptional: true }` so schema inference
+* can mark this key as optional in the inferred TypeScript type.
+*/
+BaseValidator.prototype.optional = function() {
+	const instance = this.instance;
+	instance.isOptional = true;
+	instance.requiredRule = null;
+	return instance;
+};
+/**
+* Sugar — equivalent to `.optional().nullable()`.
+*/
+BaseValidator.prototype.nullish = function() {
+	return this.optional().nullable();
+};
+/**
+* Value is required if another field exists
+*/
+BaseValidator.prototype.requiredWith = function(field, errorMessage) {
+	return this.setRequiredRule(requiredWithRule, errorMessage, {
+		field,
+		scope: "global"
+	});
+};
+/**
+* Value is required if another sibling field exists
+*/
+BaseValidator.prototype.requiredWithSibling = function(field, errorMessage) {
+	return this.setRequiredRule(requiredWithRule, errorMessage, {
+		field,
+		scope: "sibling"
+	});
+};
+/**
+* Value is required if another field is missing
+*/
+BaseValidator.prototype.requiredWithout = function(field, errorMessage) {
+	return this.setRequiredRule(requiredWithoutRule, errorMessage, {
+		field,
+		scope: "global"
+	});
+};
+/**
+* Value is required if another sibling field is missing
+*/
+BaseValidator.prototype.requiredWithoutSibling = function(field, errorMessage) {
+	return this.setRequiredRule(requiredWithoutRule, errorMessage, {
+		field,
+		scope: "sibling"
+	});
+};
+/**
+* Value is required if another field equals a specific value
+*/
+BaseValidator.prototype.requiredIf = function(field, value, errorMessage) {
+	return this.setRequiredRule(requiredIfRule, errorMessage, {
+		field,
+		value,
+		scope: "global"
+	});
+};
+/**
+* Value is required if another sibling field equals a specific value
+*/
+BaseValidator.prototype.requiredIfSibling = function(field, value, errorMessage) {
+	return this.setRequiredRule(requiredIfRule, errorMessage, {
+		field,
+		value,
+		scope: "sibling"
+	});
+};
+/**
+* Value is required unless another field equals a specific value
+*/
+BaseValidator.prototype.requiredUnless = function(field, value, errorMessage) {
+	return this.setRequiredRule(requiredUnlessRule, errorMessage, {
+		field,
+		value,
+		scope: "global"
+	});
+};
+/**
+* Value is required unless another sibling field equals a specific value
+*/
+BaseValidator.prototype.requiredUnlessSibling = function(field, value, errorMessage) {
+	return this.setRequiredRule(requiredUnlessRule, errorMessage, {
+		field,
+		value,
+		scope: "sibling"
+	});
+};
+/**
+* Value is required if another field is empty
+*/
+BaseValidator.prototype.requiredIfEmpty = function(field, errorMessage) {
+	return this.setRequiredRule(requiredIfEmptyRule, errorMessage, {
+		field,
+		scope: "global"
+	});
+};
+/**
+* Value is required if another sibling field is empty
+*/
+BaseValidator.prototype.requiredIfEmptySibling = function(field, errorMessage) {
+	return this.setRequiredRule(requiredIfEmptyRule, errorMessage, {
+		field,
+		scope: "sibling"
+	});
+};
+/**
+* Value is required if another field is not empty
+*/
+BaseValidator.prototype.requiredIfNotEmpty = function(field, errorMessage) {
+	return this.setRequiredRule(requiredIfNotEmptyRule, errorMessage, {
+		field,
+		scope: "global"
+	});
+};
+/**
+* Value is required if another sibling field is not empty
+*/
+BaseValidator.prototype.requiredIfNotEmptySibling = function(field, errorMessage) {
+	return this.setRequiredRule(requiredIfNotEmptyRule, errorMessage, {
+		field,
+		scope: "sibling"
+	});
+};
+/**
+* Value is required if ALL specified fields are empty
+*/
+BaseValidator.prototype.requiredIfAllEmpty = function(fields, errorMessage) {
+	return this.setRequiredRule(requiredIfAllEmptyRule, errorMessage, {
+		fields,
+		scope: "global"
+	});
+};
+/**
+* Value is required if ALL specified sibling fields are empty
+*/
+BaseValidator.prototype.requiredIfAllEmptySiblings = function(fields, errorMessage) {
+	return this.setRequiredRule(requiredIfAllEmptyRule, errorMessage, {
+		fields,
+		scope: "sibling"
+	});
+};
+/**
+* Value is required if ANY of the specified fields is empty
+*/
+BaseValidator.prototype.requiredIfAnyEmpty = function(fields, errorMessage) {
+	return this.setRequiredRule(requiredIfAnyEmptyRule, errorMessage, {
+		fields,
+		scope: "global"
+	});
+};
+/**
+* Value is required if ANY of the specified sibling fields is empty
+*/
+BaseValidator.prototype.requiredIfAnyEmptySiblings = function(fields, errorMessage) {
+	return this.setRequiredRule(requiredIfAnyEmptyRule, errorMessage, {
+		fields,
+		scope: "sibling"
+	});
+};
+/**
+* Value is required if ALL specified fields are NOT empty
+*/
+BaseValidator.prototype.requiredIfAllNotEmpty = function(fields, errorMessage) {
+	return this.setRequiredRule(requiredIfAllNotEmptyRule, errorMessage, {
+		fields,
+		scope: "global"
+	});
+};
+/**
+* Value is required if ALL specified sibling fields are NOT empty
+*/
+BaseValidator.prototype.requiredIfAllNotEmptySiblings = function(fields, errorMessage) {
+	return this.setRequiredRule(requiredIfAllNotEmptyRule, errorMessage, {
+		fields,
+		scope: "sibling"
+	});
+};
+/**
+* Value is required if ANY of the specified fields is NOT empty
+*/
+BaseValidator.prototype.requiredIfAnyNotEmpty = function(fields, errorMessage) {
+	return this.setRequiredRule(requiredIfAnyNotEmptyRule, errorMessage, {
+		fields,
+		scope: "global"
+	});
+};
+/**
+* Value is required if ANY of the specified sibling fields is NOT empty
+*/
+BaseValidator.prototype.requiredIfAnyNotEmptySiblings = function(fields, errorMessage) {
+	return this.setRequiredRule(requiredIfAnyNotEmptyRule, errorMessage, {
+		fields,
+		scope: "sibling"
+	});
+};
+/**
+* Value is required if another field's value is in the given array
+*/
+BaseValidator.prototype.requiredIfIn = function(field, values, errorMessage) {
+	return this.setRequiredRule(requiredIfInRule, errorMessage, {
+		field,
+		values,
+		scope: "global"
+	});
+};
+/**
+* Value is required if another sibling field's value is in the given array
+*/
+BaseValidator.prototype.requiredIfInSibling = function(field, values, errorMessage) {
+	return this.setRequiredRule(requiredIfInRule, errorMessage, {
+		field,
+		values,
+		scope: "sibling"
+	});
+};
+/**
+* Value is required if another field's value is NOT in the given array
+*/
+BaseValidator.prototype.requiredIfNotIn = function(field, values, errorMessage) {
+	return this.setRequiredRule(requiredIfNotInRule, errorMessage, {
+		field,
+		values,
+		scope: "global"
+	});
+};
+/**
+* Value is required if another sibling field's value is NOT in the given array
+*/
+BaseValidator.prototype.requiredIfNotInSibling = function(field, values, errorMessage) {
+	return this.setRequiredRule(requiredIfNotInRule, errorMessage, {
+		field,
+		values,
+		scope: "sibling"
+	});
+};
+/**
+* Value is required if all specified fields exist
+*/
+BaseValidator.prototype.requiredWithAll = function(fields, errorMessage) {
+	return this.setRequiredRule(requiredWithAllRule, errorMessage, {
+		fields,
+		scope: "global"
+	});
+};
+/**
+* Value is required if all specified sibling fields exist
+*/
+BaseValidator.prototype.requiredWithAllSiblings = function(fields, errorMessage) {
+	return this.setRequiredRule(requiredWithAllRule, errorMessage, {
+		fields,
+		scope: "sibling"
+	});
+};
+/**
+* Value is required if all specified fields are missing
+*/
+BaseValidator.prototype.requiredWithoutAll = function(fields, errorMessage) {
+	return this.setRequiredRule(requiredWithoutAllRule, errorMessage, {
+		fields,
+		scope: "global"
+	});
+};
+/**
+* Value is required if all specified sibling fields are missing
+*/
+BaseValidator.prototype.requiredWithoutAllSiblings = function(fields, errorMessage) {
+	return this.setRequiredRule(requiredWithoutAllRule, errorMessage, {
+		fields,
+		scope: "sibling"
+	});
+};
+/**
+* Value is required if any of the specified fields exists
+*/
+BaseValidator.prototype.requiredWithAny = function(fields, errorMessage) {
+	return this.setRequiredRule(requiredWithAnyRule, errorMessage, {
+		fields,
+		scope: "global"
+	});
+};
+/**
+* Value is required if any of the specified sibling fields exists
+*/
+BaseValidator.prototype.requiredWithAnySiblings = function(fields, errorMessage) {
+	return this.setRequiredRule(requiredWithAnyRule, errorMessage, {
+		fields,
+		scope: "sibling"
+	});
+};
+/**
+* Value is required if any of the specified fields is missing
+*/
+BaseValidator.prototype.requiredWithoutAny = function(fields, errorMessage) {
+	return this.setRequiredRule(requiredWithoutAnyRule, errorMessage, {
+		fields,
+		scope: "global"
+	});
+};
+/**
+* Value is required if any of the specified sibling fields is missing
+*/
+BaseValidator.prototype.requiredWithoutAnySiblings = function(fields, errorMessage) {
+	return this.setRequiredRule(requiredWithoutAnyRule, errorMessage, {
+		fields,
+		scope: "sibling"
+	});
+};
+/**
+* Make this field required based on a custom callback.
+* Callback receives only SchemaContext — the framework handles empty-value checking.
+*/
+BaseValidator.prototype.requiredWhen = function(callback, errorMessage) {
+	return this.setRequiredRule(requiredWhenRule, errorMessage, { callback });
+};
+
+//#endregion
+export {  };
+//# sourceMappingURL=required-methods.mjs.map

package/esm/validators/methods/required-methods.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"required-methods.mjs","names":[],"sources":["../../../../../../../@warlock.js/seal/src/validators/methods/required-methods.ts"],"sourcesContent":["import {\n  requiredIfAllEmptyRule,\n  requiredIfAllNotEmptyRule,\n  requiredIfAnyEmptyRule,\n  requiredIfAnyNotEmptyRule,\n  requiredIfEmptyRule,\n  requiredIfInRule,\n  requiredIfNotEmptyRule,\n  requiredIfNotInRule,\n  requiredIfRule,\n} from \"../../rules/conditional/required-if-rules\";\nimport { requiredUnlessRule } from \"../../rules/conditional/required-unless-rules\";\nimport { requiredWhenRule } from \"../../rules/conditional/required-when-rule\";\nimport {\n  requiredWithAllRule,\n  requiredWithAnyRule,\n  requiredWithRule,\n} from \"../../rules/conditional/required-with-rules\";\nimport {\n  requiredWithoutAllRule,\n  requiredWithoutAnyRule,\n  requiredWithoutRule,\n} from \"../../rules/conditional/required-without-rules\";\nimport { presentRule, requiredRule } from \"../../rules/core/required\";\nimport type { SchemaContext } from \"../../types\";\nimport { BaseValidator } from \"../base-validator\";\n\ndeclare module \"../base-validator\" {\n  interface BaseValidator {\n    /**\n     * This value must be present and has a value\n     */\n    required(errorMessage?: string): this;\n\n    /**\n     * Value must be present but not necessarily has a value\n     */\n    present(errorMessage?: string): this;\n\n    /**\n     * Mark the field as optional, so pass it if it has no value or has a value\n     * Because this is the default behavior, this method is just syntactic sugar\n     */\n    optional(): this & { isOptional: true };\n\n    /**\n     * Sugar for `.optional().nullable()` — the field may be absent OR null.\n     *\n     * Brands the return type with both `{ isOptional: true }` and `{ isNullable: true }`\n     * so `Infer<>` produces `{ field?: T | null }`.\n     *\n     * @example\n     * v.string().nullish()\n     * // type: string | null | undefined\n     * //   absent  → key omitted\n     * //   null    → null\n     * //   \"x\"     → \"x\"\n     */\n    nullish(): this & { isOptional: true; isNullable: true };\n\n    /**\n     * Value is required if another field exists\n     */\n    requiredWith(field: string, errorMessage?: string): this;\n\n    /**\n     * Value is required if another sibling field exists\n     */\n    requiredWithSibling(field: string, errorMessage?: string): this;\n\n    /**\n     * Value is required if another field is missing\n     */\n    requiredWithout(field: string, errorMessage?: string): this;\n\n    /**\n     * Value is required if another sibling field is missing\n     */\n    requiredWithoutSibling(field: string, errorMessage?: string): this;\n\n    /**\n     * Value is required if another field equals a specific value\n     */\n    requiredIf(field: string, value: any, errorMessage?: string): this;\n\n    /**\n     * Value is required if another sibling field equals a specific value\n     */\n    requiredIfSibling(field: string, value: any, errorMessage?: string): this;\n\n    /**\n     * Value is required unless another field equals a specific value\n     */\n    requiredUnless(field: string, value: any, errorMessage?: string): this;\n\n    /**\n     * Value is required unless another sibling field equals a specific value\n     */\n    requiredUnlessSibling(field: string, value: any, errorMessage?: string): this;\n\n    /**\n     * Value is required if another field is empty\n     */\n    requiredIfEmpty(field: string, errorMessage?: string): this;\n\n    /**\n     * Value is required if another sibling field is empty\n     */\n    requiredIfEmptySibling(field: string, errorMessage?: string): this;\n\n    /**\n     * Value is required if another field is not empty\n     */\n    requiredIfNotEmpty(field: string, errorMessage?: string): this;\n\n    /**\n     * Value is required if another sibling field is not empty\n     */\n    requiredIfNotEmptySibling(field: string, errorMessage?: string): this;\n\n    /**\n     * Value is required if ALL specified fields are empty\n     */\n    requiredIfAllEmpty(fields: string[], errorMessage?: string): this;\n\n    /**\n     * Value is required if ALL specified sibling fields are empty\n     */\n    requiredIfAllEmptySiblings(fields: string[], errorMessage?: string): this;\n\n    /**\n     * Value is required if ANY of the specified fields is empty\n     */\n    requiredIfAnyEmpty(fields: string[], errorMessage?: string): this;\n\n    /**\n     * Value is required if ANY of the specified sibling fields is empty\n     */\n    requiredIfAnyEmptySiblings(fields: string[], errorMessage?: string): this;\n\n    /**\n     * Value is required if ALL specified fields are NOT empty\n     */\n    requiredIfAllNotEmpty(fields: string[], errorMessage?: string): this;\n\n    /**\n     * Value is required if ALL specified sibling fields are NOT empty\n     */\n    requiredIfAllNotEmptySiblings(fields: string[], errorMessage?: string): this;\n\n    /**\n     * Value is required if ANY of the specified fields is NOT empty\n     */\n    requiredIfAnyNotEmpty(fields: string[], errorMessage?: string): this;\n\n    /**\n     * Value is required if ANY of the specified sibling fields is NOT empty\n     */\n    requiredIfAnyNotEmptySiblings(fields: string[], errorMessage?: string): this;\n\n    /**\n     * Value is required if another field's value is in the given array\n     */\n    requiredIfIn(field: string, values: any[], errorMessage?: string): this;\n\n    /**\n     * Value is required if another sibling field's value is in the given array\n     */\n    requiredIfInSibling(field: string, values: any[], errorMessage?: string): this;\n\n    /**\n     * Value is required if another field's value is NOT in the given array\n     */\n    requiredIfNotIn(field: string, values: any[], errorMessage?: string): this;\n\n    /**\n     * Value is required if another sibling field's value is NOT in the given array\n     */\n    requiredIfNotInSibling(field: string, values: any[], errorMessage?: string): this;\n\n    /**\n     * Value is required if all specified fields exist\n     */\n    requiredWithAll(fields: string[], errorMessage?: string): this;\n\n    /**\n     * Value is required if all specified sibling fields exist\n     */\n    requiredWithAllSiblings(fields: string[], errorMessage?: string): this;\n\n    /**\n     * Value is required if all specified fields are missing\n     */\n    requiredWithoutAll(fields: string[], errorMessage?: string): this;\n\n    /**\n     * Value is required if all specified sibling fields are missing\n     */\n    requiredWithoutAllSiblings(fields: string[], errorMessage?: string): this;\n\n    /**\n     * Value is required if any of the specified fields exists\n     */\n    requiredWithAny(fields: string[], errorMessage?: string): this;\n\n    /**\n     * Value is required if any of the specified sibling fields exists\n     */\n    requiredWithAnySiblings(fields: string[], errorMessage?: string): this;\n\n    /**\n     * Value is required if any of the specified fields is missing\n     */\n    requiredWithoutAny(fields: string[], errorMessage?: string): this;\n\n    /**\n     * Value is required if any of the specified sibling fields is missing\n     */\n    requiredWithoutAnySiblings(fields: string[], errorMessage?: string): this;\n\n    /**\n     * Make this field required based on a custom callback.\n     *\n     * The callback receives only the `SchemaContext` (not the value),\n     * because \"required\" is about surrounding conditions, not the field itself.\n     * Return `true` if the field should be required.\n     *\n     * @param callback - Receives SchemaContext, returns boolean\n     * @param errorMessage - Optional custom error message\n     *\n     * @example\n     * ```ts\n     * // Required when email notification is enabled\n     * v.string().requiredWhen((context) => {\n     *   return context.allData.notificationMethod === 'email';\n     * })\n     *\n     * // Required based on multiple conditions\n     * v.string().requiredWhen((context) => {\n     *   const { role, department } = context.allData;\n     *   return role === 'manager' && department === 'finance';\n     * })\n     * ```\n     */\n    requiredWhen(\n      callback: (context: SchemaContext) => boolean | Promise<boolean>,\n      errorMessage?: string,\n    ): this;\n  }\n}\n\n// ==================== UNCONDITIONAL STATES ====================\n\n/**\n * This value must be present and has a value\n */\nBaseValidator.prototype.required = function (errorMessage?: string) {\n  return this.setRequiredRule(requiredRule, errorMessage);\n};\n\n/**\n * Value must be present but not necessarily has a value\n */\nBaseValidator.prototype.present = function (errorMessage?: string) {\n  return this.setRequiredRule(presentRule, errorMessage);\n};\n\n/**\n * Mark the field as optional — it may be absent or empty without validation errors.\n * Clears any previously set required rule.\n *\n * The return type is branded with `{ isOptional: true }` so schema inference\n * can mark this key as optional in the inferred TypeScript type.\n */\nBaseValidator.prototype.optional = function (): BaseValidator & { isOptional: true } {\n  const instance = this.instance;\n  instance.isOptional = true;\n  instance.requiredRule = null;\n  return instance as BaseValidator & { isOptional: true };\n};\n\n/**\n * Sugar — equivalent to `.optional().nullable()`.\n */\nBaseValidator.prototype.nullish = function (): BaseValidator & {\n  isOptional: true;\n  isNullable: true;\n} {\n  const instance = this.optional().nullable();\n  return instance as BaseValidator & { isOptional: true; isNullable: true };\n};\n\n// ==================== REQUIRED: BASED ON FIELD PRESENCE ====================\n\n/**\n * Value is required if another field exists\n */\nBaseValidator.prototype.requiredWith = function (field: string, errorMessage?: string) {\n  return this.setRequiredRule(requiredWithRule, errorMessage, { field, scope: \"global\" });\n};\n\n/**\n * Value is required if another sibling field exists\n */\nBaseValidator.prototype.requiredWithSibling = function (field: string, errorMessage?: string) {\n  return this.setRequiredRule(requiredWithRule, errorMessage, { field, scope: \"sibling\" });\n};\n\n/**\n * Value is required if another field is missing\n */\nBaseValidator.prototype.requiredWithout = function (field: string, errorMessage?: string) {\n  return this.setRequiredRule(requiredWithoutRule, errorMessage, { field, scope: \"global\" });\n};\n\n/**\n * Value is required if another sibling field is missing\n */\nBaseValidator.prototype.requiredWithoutSibling = function (field: string, errorMessage?: string) {\n  return this.setRequiredRule(requiredWithoutRule, errorMessage, { field, scope: \"sibling\" });\n};\n\n// ==================== REQUIRED: BASED ON FIELD VALUE ====================\n\n/**\n * Value is required if another field equals a specific value\n */\nBaseValidator.prototype.requiredIf = function (field: string, value: any, errorMessage?: string) {\n  return this.setRequiredRule(requiredIfRule, errorMessage, { field, value, scope: \"global\" });\n};\n\n/**\n * Value is required if another sibling field equals a specific value\n */\nBaseValidator.prototype.requiredIfSibling = function (\n  field: string,\n  value: any,\n  errorMessage?: string,\n) {\n  return this.setRequiredRule(requiredIfRule, errorMessage, { field, value, scope: \"sibling\" });\n};\n\n/**\n * Value is required unless another field equals a specific value\n */\nBaseValidator.prototype.requiredUnless = function (\n  field: string,\n  value: any,\n  errorMessage?: string,\n) {\n  return this.setRequiredRule(requiredUnlessRule, errorMessage, { field, value, scope: \"global\" });\n};\n\n/**\n * Value is required unless another sibling field equals a specific value\n */\nBaseValidator.prototype.requiredUnlessSibling = function (\n  field: string,\n  value: any,\n  errorMessage?: string,\n) {\n  return this.setRequiredRule(requiredUnlessRule, errorMessage, { field, value, scope: \"sibling\" });\n};\n\n// ==================== REQUIRED: BASED ON FIELD EMPTY STATE ====================\n\n/**\n * Value is required if another field is empty\n */\nBaseValidator.prototype.requiredIfEmpty = function (field: string, errorMessage?: string) {\n  return this.setRequiredRule(requiredIfEmptyRule, errorMessage, { field, scope: \"global\" });\n};\n\n/**\n * Value is required if another sibling field is empty\n */\nBaseValidator.prototype.requiredIfEmptySibling = function (field: string, errorMessage?: string) {\n  return this.setRequiredRule(requiredIfEmptyRule, errorMessage, { field, scope: \"sibling\" });\n};\n\n/**\n * Value is required if another field is not empty\n */\nBaseValidator.prototype.requiredIfNotEmpty = function (field: string, errorMessage?: string) {\n  return this.setRequiredRule(requiredIfNotEmptyRule, errorMessage, { field, scope: \"global\" });\n};\n\n/**\n * Value is required if another sibling field is not empty\n */\nBaseValidator.prototype.requiredIfNotEmptySibling = function (\n  field: string,\n  errorMessage?: string,\n) {\n  return this.setRequiredRule(requiredIfNotEmptyRule, errorMessage, { field, scope: \"sibling\" });\n};\n\n// ==================== REQUIRED: BASED ON MULTIPLE FIELDS EMPTY STATE ====================\n\n/**\n * Value is required if ALL specified fields are empty\n */\nBaseValidator.prototype.requiredIfAllEmpty = function (fields: string[], errorMessage?: string) {\n  return this.setRequiredRule(requiredIfAllEmptyRule, errorMessage, { fields, scope: \"global\" });\n};\n\n/**\n * Value is required if ALL specified sibling fields are empty\n */\nBaseValidator.prototype.requiredIfAllEmptySiblings = function (\n  fields: string[],\n  errorMessage?: string,\n) {\n  return this.setRequiredRule(requiredIfAllEmptyRule, errorMessage, { fields, scope: \"sibling\" });\n};\n\n/**\n * Value is required if ANY of the specified fields is empty\n */\nBaseValidator.prototype.requiredIfAnyEmpty = function (fields: string[], errorMessage?: string) {\n  return this.setRequiredRule(requiredIfAnyEmptyRule, errorMessage, { fields, scope: \"global\" });\n};\n\n/**\n * Value is required if ANY of the specified sibling fields is empty\n */\nBaseValidator.prototype.requiredIfAnyEmptySiblings = function (\n  fields: string[],\n  errorMessage?: string,\n) {\n  return this.setRequiredRule(requiredIfAnyEmptyRule, errorMessage, { fields, scope: \"sibling\" });\n};\n\n/**\n * Value is required if ALL specified fields are NOT empty\n */\nBaseValidator.prototype.requiredIfAllNotEmpty = function (fields: string[], errorMessage?: string) {\n  return this.setRequiredRule(requiredIfAllNotEmptyRule, errorMessage, { fields, scope: \"global\" });\n};\n\n/**\n * Value is required if ALL specified sibling fields are NOT empty\n */\nBaseValidator.prototype.requiredIfAllNotEmptySiblings = function (\n  fields: string[],\n  errorMessage?: string,\n) {\n  return this.setRequiredRule(requiredIfAllNotEmptyRule, errorMessage, {\n    fields,\n    scope: \"sibling\",\n  });\n};\n\n/**\n * Value is required if ANY of the specified fields is NOT empty\n */\nBaseValidator.prototype.requiredIfAnyNotEmpty = function (fields: string[], errorMessage?: string) {\n  return this.setRequiredRule(requiredIfAnyNotEmptyRule, errorMessage, { fields, scope: \"global\" });\n};\n\n/**\n * Value is required if ANY of the specified sibling fields is NOT empty\n */\nBaseValidator.prototype.requiredIfAnyNotEmptySiblings = function (\n  fields: string[],\n  errorMessage?: string,\n) {\n  return this.setRequiredRule(requiredIfAnyNotEmptyRule, errorMessage, {\n    fields,\n    scope: \"sibling\",\n  });\n};\n\n/**\n * Value is required if another field's value is in the given array\n */\nBaseValidator.prototype.requiredIfIn = function (\n  field: string,\n  values: any[],\n  errorMessage?: string,\n) {\n  return this.setRequiredRule(requiredIfInRule, errorMessage, { field, values, scope: \"global\" });\n};\n\n/**\n * Value is required if another sibling field's value is in the given array\n */\nBaseValidator.prototype.requiredIfInSibling = function (\n  field: string,\n  values: any[],\n  errorMessage?: string,\n) {\n  return this.setRequiredRule(requiredIfInRule, errorMessage, { field, values, scope: \"sibling\" });\n};\n\n/**\n * Value is required if another field's value is NOT in the given array\n */\nBaseValidator.prototype.requiredIfNotIn = function (\n  field: string,\n  values: any[],\n  errorMessage?: string,\n) {\n  return this.setRequiredRule(requiredIfNotInRule, errorMessage, {\n    field,\n    values,\n    scope: \"global\",\n  });\n};\n\n/**\n * Value is required if another sibling field's value is NOT in the given array\n */\nBaseValidator.prototype.requiredIfNotInSibling = function (\n  field: string,\n  values: any[],\n  errorMessage?: string,\n) {\n  return this.setRequiredRule(requiredIfNotInRule, errorMessage, {\n    field,\n    values,\n    scope: \"sibling\",\n  });\n};\n\n// ==================== REQUIRED: BASED ON MULTIPLE FIELDS (ALL) ====================\n\n/**\n * Value is required if all specified fields exist\n */\nBaseValidator.prototype.requiredWithAll = function (fields: string[], errorMessage?: string) {\n  return this.setRequiredRule(requiredWithAllRule, errorMessage, { fields, scope: \"global\" });\n};\n\n/**\n * Value is required if all specified sibling fields exist\n */\nBaseValidator.prototype.requiredWithAllSiblings = function (\n  fields: string[],\n  errorMessage?: string,\n) {\n  return this.setRequiredRule(requiredWithAllRule, errorMessage, { fields, scope: \"sibling\" });\n};\n\n/**\n * Value is required if all specified fields are missing\n */\nBaseValidator.prototype.requiredWithoutAll = function (fields: string[], errorMessage?: string) {\n  return this.setRequiredRule(requiredWithoutAllRule, errorMessage, { fields, scope: \"global\" });\n};\n\n/**\n * Value is required if all specified sibling fields are missing\n */\nBaseValidator.prototype.requiredWithoutAllSiblings = function (\n  fields: string[],\n  errorMessage?: string,\n) {\n  return this.setRequiredRule(requiredWithoutAllRule, errorMessage, { fields, scope: \"sibling\" });\n};\n\n// ==================== REQUIRED: BASED ON MULTIPLE FIELDS (ANY) ====================\n\n/**\n * Value is required if any of the specified fields exists\n */\nBaseValidator.prototype.requiredWithAny = function (fields: string[], errorMessage?: string) {\n  return this.setRequiredRule(requiredWithAnyRule, errorMessage, { fields, scope: \"global\" });\n};\n\n/**\n * Value is required if any of the specified sibling fields exists\n */\nBaseValidator.prototype.requiredWithAnySiblings = function (\n  fields: string[],\n  errorMessage?: string,\n) {\n  return this.setRequiredRule(requiredWithAnyRule, errorMessage, { fields, scope: \"sibling\" });\n};\n\n/**\n * Value is required if any of the specified fields is missing\n */\nBaseValidator.prototype.requiredWithoutAny = function (fields: string[], errorMessage?: string) {\n  return this.setRequiredRule(requiredWithoutAnyRule, errorMessage, { fields, scope: \"global\" });\n};\n\n/**\n * Value is required if any of the specified sibling fields is missing\n */\nBaseValidator.prototype.requiredWithoutAnySiblings = function (\n  fields: string[],\n  errorMessage?: string,\n) {\n  return this.setRequiredRule(requiredWithoutAnyRule, errorMessage, { fields, scope: \"sibling\" });\n};\n\n// ==================== REQUIRED: BASED ON CUSTOM CALLBACK ====================\n\n/**\n * Make this field required based on a custom callback.\n * Callback receives only SchemaContext — the framework handles empty-value checking.\n */\nBaseValidator.prototype.requiredWhen = function (\n  callback: (context: SchemaContext) => boolean | Promise<boolean>,\n  errorMessage?: string,\n) {\n  return this.setRequiredRule(requiredWhenRule, errorMessage, { callback });\n};\n"],"mappings":"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"}