@warlock.js/seal 4.0.134 → 4.0.136

package/cjs/validators/methods/present-methods.js

@@ -0,0 +1,229 @@
+'use strict';var presentIfRules=require('../../rules/conditional/present-if-rules.js'),presentUnlessRules=require('../../rules/conditional/present-unless-rules.js'),presentWithRules=require('../../rules/conditional/present-with-rules.js'),presentWithoutRules=require('../../rules/conditional/present-without-rules.js'),baseValidator=require('../base-validator.js');// ==================== PRESENT: BASED ON FIELD PRESENCE ====================
+/**
+ * Field must be present if another field exists
+ */
+baseValidator.BaseValidator.prototype.presentWith = function (field, errorMessage) {
+    return this.addRule(presentWithRules.presentWithRule, errorMessage, {
+        field,
+        scope: "global",
+    });
+};
+/**
+ * Field must be present if another sibling field exists
+ */
+baseValidator.BaseValidator.prototype.presentWithSibling = function (field, errorMessage) {
+    return this.addRule(presentWithRules.presentWithRule, errorMessage, {
+        field,
+        scope: "sibling",
+    });
+};
+/**
+ * Field must be present if another field is missing
+ */
+baseValidator.BaseValidator.prototype.presentWithout = function (field, errorMessage) {
+    return this.addRule(presentWithoutRules.presentWithoutRule, errorMessage, {
+        field,
+        scope: "global",
+    });
+};
+/**
+ * Field must be present if another sibling field is missing
+ */
+baseValidator.BaseValidator.prototype.presentWithoutSibling = function (field, errorMessage) {
+    return this.addRule(presentWithoutRules.presentWithoutRule, errorMessage, {
+        field,
+        scope: "sibling",
+    });
+};
+// ==================== PRESENT: BASED ON FIELD VALUE ====================
+/**
+ * Field must be present if another field equals a specific value
+ */
+baseValidator.BaseValidator.prototype.presentIf = function (field, value, errorMessage) {
+    return this.addRule(presentIfRules.presentIfRule, errorMessage, {
+        field,
+        value,
+        scope: "global",
+    });
+};
+/**
+ * Field must be present if another sibling field equals a specific value
+ */
+baseValidator.BaseValidator.prototype.presentIfSibling = function (field, value, errorMessage) {
+    return this.addRule(presentIfRules.presentIfRule, errorMessage, {
+        field,
+        value,
+        scope: "sibling",
+    });
+};
+/**
+ * Field must be present unless another field equals a specific value
+ */
+baseValidator.BaseValidator.prototype.presentUnless = function (field, value, errorMessage) {
+    return this.addRule(presentUnlessRules.presentUnlessRule, errorMessage, {
+        field,
+        value,
+        scope: "global",
+    });
+};
+/**
+ * Field must be present unless another sibling field equals a specific value
+ */
+baseValidator.BaseValidator.prototype.presentUnlessSibling = function (field, value, errorMessage) {
+    return this.addRule(presentUnlessRules.presentUnlessRule, errorMessage, {
+        field,
+        value,
+        scope: "sibling",
+    });
+};
+// ==================== PRESENT: BASED ON FIELD EMPTY STATE ====================
+/**
+ * Field must be present if another field is empty
+ */
+baseValidator.BaseValidator.prototype.presentIfEmpty = function (field, errorMessage) {
+    return this.addRule(presentIfRules.presentIfEmptyRule, errorMessage, {
+        field,
+        scope: "global",
+    });
+};
+/**
+ * Field must be present if another sibling field is empty
+ */
+baseValidator.BaseValidator.prototype.presentIfEmptySibling = function (field, errorMessage) {
+    return this.addRule(presentIfRules.presentIfEmptyRule, errorMessage, {
+        field,
+        scope: "sibling",
+    });
+};
+/**
+ * Field must be present if another field is not empty
+ */
+baseValidator.BaseValidator.prototype.presentIfNotEmpty = function (field, errorMessage) {
+    return this.addRule(presentIfRules.presentIfNotEmptyRule, errorMessage, {
+        field,
+        scope: "global",
+    });
+};
+/**
+ * Field must be present if another sibling field is not empty
+ */
+baseValidator.BaseValidator.prototype.presentIfNotEmptySibling = function (field, errorMessage) {
+    return this.addRule(presentIfRules.presentIfNotEmptyRule, errorMessage, {
+        field,
+        scope: "sibling",
+    });
+};
+/**
+ * Field must be present if another field's value is in the given array
+ */
+baseValidator.BaseValidator.prototype.presentIfIn = function (field, values, errorMessage) {
+    return this.addRule(presentIfRules.presentIfInRule, errorMessage, {
+        field,
+        values,
+        scope: "global",
+    });
+};
+/**
+ * Field must be present if another sibling field's value is in the given array
+ */
+baseValidator.BaseValidator.prototype.presentIfInSibling = function (field, values, errorMessage) {
+    return this.addRule(presentIfRules.presentIfInRule, errorMessage, {
+        field,
+        values,
+        scope: "sibling",
+    });
+};
+/**
+ * Field must be present if another field's value is NOT in the given array
+ */
+baseValidator.BaseValidator.prototype.presentIfNotIn = function (field, values, errorMessage) {
+    return this.addRule(presentIfRules.presentIfNotInRule, errorMessage, {
+        field,
+        values,
+        scope: "global",
+    });
+};
+/**
+ * Field must be present if another sibling field's value is NOT in the given array
+ */
+baseValidator.BaseValidator.prototype.presentIfNotInSibling = function (field, values, errorMessage) {
+    return this.addRule(presentIfRules.presentIfNotInRule, errorMessage, {
+        field,
+        values,
+        scope: "sibling",
+    });
+};
+// ==================== PRESENT: BASED ON MULTIPLE FIELDS (ALL) ====================
+/**
+ * Field must be present if all specified fields exist
+ */
+baseValidator.BaseValidator.prototype.presentWithAll = function (fields, errorMessage) {
+    return this.addRule(presentWithRules.presentWithAllRule, errorMessage, {
+        fields,
+        scope: "global",
+    });
+};
+/**
+ * Field must be present if all specified sibling fields exist
+ */
+baseValidator.BaseValidator.prototype.presentWithAllSiblings = function (fields, errorMessage) {
+    return this.addRule(presentWithRules.presentWithAllRule, errorMessage, {
+        fields,
+        scope: "sibling",
+    });
+};
+/**
+ * Field must be present if all specified fields are missing
+ */
+baseValidator.BaseValidator.prototype.presentWithoutAll = function (fields, errorMessage) {
+    return this.addRule(presentWithoutRules.presentWithoutAllRule, errorMessage, {
+        fields,
+        scope: "global",
+    });
+};
+/**
+ * Field must be present if all specified sibling fields are missing
+ */
+baseValidator.BaseValidator.prototype.presentWithoutAllSiblings = function (fields, errorMessage) {
+    return this.addRule(presentWithoutRules.presentWithoutAllRule, errorMessage, {
+        fields,
+        scope: "sibling",
+    });
+};
+// ==================== PRESENT: BASED ON MULTIPLE FIELDS (ANY) ====================
+/**
+ * Field must be present if any of the specified fields exists
+ */
+baseValidator.BaseValidator.prototype.presentWithAny = function (fields, errorMessage) {
+    return this.addRule(presentWithRules.presentWithAnyRule, errorMessage, {
+        fields,
+        scope: "global",
+    });
+};
+/**
+ * Field must be present if any of the specified sibling fields exists
+ */
+baseValidator.BaseValidator.prototype.presentWithAnySiblings = function (fields, errorMessage) {
+    return this.addRule(presentWithRules.presentWithAnyRule, errorMessage, {
+        fields,
+        scope: "sibling",
+    });
+};
+/**
+ * Field must be present if any of the specified fields is missing
+ */
+baseValidator.BaseValidator.prototype.presentWithoutAny = function (fields, errorMessage) {
+    return this.addRule(presentWithoutRules.presentWithoutAnyRule, errorMessage, {
+        fields,
+        scope: "global",
+    });
+};
+/**
+ * Field must be present if any of the specified sibling fields is missing
+ */
+baseValidator.BaseValidator.prototype.presentWithoutAnySiblings = function (fields, errorMessage) {
+    return this.addRule(presentWithoutRules.presentWithoutAnyRule, errorMessage, {
+        fields,
+        scope: "sibling",
+    });
+};//# sourceMappingURL=present-methods.js.map

package/cjs/validators/methods/present-methods.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"present-methods.js","sources":["../../../src/validators/methods/present-methods.ts"],"sourcesContent":[null],"names":["BaseValidator","presentWithRule","presentWithoutRule","presentIfRule","presentUnlessRule","presentIfEmptyRule","presentIfNotEmptyRule","presentIfInRule","presentIfNotInRule","presentWithAllRule","presentWithoutAllRule","presentWithAnyRule","presentWithoutAnyRule"],"mappings":"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"}

package/cjs/validators/methods/required-methods.d.ts

@@ -0,0 +1,174 @@
+import type { SchemaContext } from "../../types";
+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;
+        };
+        /**
+         * 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

package/cjs/validators/methods/required-methods.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"required-methods.d.ts","sourceRoot":"","sources":["../../../src/validators/methods/required-methods.ts"],"names":[],"mappings":"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"}

package/cjs/validators/methods/required-methods.js

@@ -0,0 +1,246 @@
+'use strict';var requiredIfRules=require('../../rules/conditional/required-if-rules.js'),requiredUnlessRules=require('../../rules/conditional/required-unless-rules.js'),requiredWhenRule=require('../../rules/conditional/required-when-rule.js'),requiredWithRules=require('../../rules/conditional/required-with-rules.js'),requiredWithoutRules=require('../../rules/conditional/required-without-rules.js'),required=require('../../rules/core/required.js'),baseValidator=require('../base-validator.js');// ==================== UNCONDITIONAL STATES ====================
+/**
+ * This value must be present and has a value
+ */
+baseValidator.BaseValidator.prototype.required = function (errorMessage) {
+    return this.addRule(required.requiredRule, errorMessage);
+};
+/**
+ * Value must be present but not necessarily has a value
+ */
+baseValidator.BaseValidator.prototype.present = function (errorMessage) {
+    return this.setRequiredRule(required.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.BaseValidator.prototype.optional = function () {
+    const instance = this.instance;
+    instance.isOptional = true;
+    instance.requiredRule = null;
+    return instance;
+};
+// ==================== REQUIRED: BASED ON FIELD PRESENCE ====================
+/**
+ * Value is required if another field exists
+ */
+baseValidator.BaseValidator.prototype.requiredWith = function (field, errorMessage) {
+    return this.setRequiredRule(requiredWithRules.requiredWithRule, errorMessage, { field, scope: "global" });
+};
+/**
+ * Value is required if another sibling field exists
+ */
+baseValidator.BaseValidator.prototype.requiredWithSibling = function (field, errorMessage) {
+    return this.setRequiredRule(requiredWithRules.requiredWithRule, errorMessage, { field, scope: "sibling" });
+};
+/**
+ * Value is required if another field is missing
+ */
+baseValidator.BaseValidator.prototype.requiredWithout = function (field, errorMessage) {
+    return this.setRequiredRule(requiredWithoutRules.requiredWithoutRule, errorMessage, { field, scope: "global" });
+};
+/**
+ * Value is required if another sibling field is missing
+ */
+baseValidator.BaseValidator.prototype.requiredWithoutSibling = function (field, errorMessage) {
+    return this.setRequiredRule(requiredWithoutRules.requiredWithoutRule, errorMessage, { field, scope: "sibling" });
+};
+// ==================== REQUIRED: BASED ON FIELD VALUE ====================
+/**
+ * Value is required if another field equals a specific value
+ */
+baseValidator.BaseValidator.prototype.requiredIf = function (field, value, errorMessage) {
+    return this.setRequiredRule(requiredIfRules.requiredIfRule, errorMessage, { field, value, scope: "global" });
+};
+/**
+ * Value is required if another sibling field equals a specific value
+ */
+baseValidator.BaseValidator.prototype.requiredIfSibling = function (field, value, errorMessage) {
+    return this.setRequiredRule(requiredIfRules.requiredIfRule, errorMessage, { field, value, scope: "sibling" });
+};
+/**
+ * Value is required unless another field equals a specific value
+ */
+baseValidator.BaseValidator.prototype.requiredUnless = function (field, value, errorMessage) {
+    return this.setRequiredRule(requiredUnlessRules.requiredUnlessRule, errorMessage, { field, value, scope: "global" });
+};
+/**
+ * Value is required unless another sibling field equals a specific value
+ */
+baseValidator.BaseValidator.prototype.requiredUnlessSibling = function (field, value, errorMessage) {
+    return this.setRequiredRule(requiredUnlessRules.requiredUnlessRule, errorMessage, { field, value, scope: "sibling" });
+};
+// ==================== REQUIRED: BASED ON FIELD EMPTY STATE ====================
+/**
+ * Value is required if another field is empty
+ */
+baseValidator.BaseValidator.prototype.requiredIfEmpty = function (field, errorMessage) {
+    return this.setRequiredRule(requiredIfRules.requiredIfEmptyRule, errorMessage, { field, scope: "global" });
+};
+/**
+ * Value is required if another sibling field is empty
+ */
+baseValidator.BaseValidator.prototype.requiredIfEmptySibling = function (field, errorMessage) {
+    return this.setRequiredRule(requiredIfRules.requiredIfEmptyRule, errorMessage, { field, scope: "sibling" });
+};
+/**
+ * Value is required if another field is not empty
+ */
+baseValidator.BaseValidator.prototype.requiredIfNotEmpty = function (field, errorMessage) {
+    return this.setRequiredRule(requiredIfRules.requiredIfNotEmptyRule, errorMessage, { field, scope: "global" });
+};
+/**
+ * Value is required if another sibling field is not empty
+ */
+baseValidator.BaseValidator.prototype.requiredIfNotEmptySibling = function (field, errorMessage) {
+    return this.setRequiredRule(requiredIfRules.requiredIfNotEmptyRule, errorMessage, { field, scope: "sibling" });
+};
+// ==================== REQUIRED: BASED ON MULTIPLE FIELDS EMPTY STATE ====================
+/**
+ * Value is required if ALL specified fields are empty
+ */
+baseValidator.BaseValidator.prototype.requiredIfAllEmpty = function (fields, errorMessage) {
+    return this.setRequiredRule(requiredIfRules.requiredIfAllEmptyRule, errorMessage, { fields, scope: "global" });
+};
+/**
+ * Value is required if ALL specified sibling fields are empty
+ */
+baseValidator.BaseValidator.prototype.requiredIfAllEmptySiblings = function (fields, errorMessage) {
+    return this.setRequiredRule(requiredIfRules.requiredIfAllEmptyRule, errorMessage, { fields, scope: "sibling" });
+};
+/**
+ * Value is required if ANY of the specified fields is empty
+ */
+baseValidator.BaseValidator.prototype.requiredIfAnyEmpty = function (fields, errorMessage) {
+    return this.setRequiredRule(requiredIfRules.requiredIfAnyEmptyRule, errorMessage, { fields, scope: "global" });
+};
+/**
+ * Value is required if ANY of the specified sibling fields is empty
+ */
+baseValidator.BaseValidator.prototype.requiredIfAnyEmptySiblings = function (fields, errorMessage) {
+    return this.setRequiredRule(requiredIfRules.requiredIfAnyEmptyRule, errorMessage, { fields, scope: "sibling" });
+};
+/**
+ * Value is required if ALL specified fields are NOT empty
+ */
+baseValidator.BaseValidator.prototype.requiredIfAllNotEmpty = function (fields, errorMessage) {
+    return this.setRequiredRule(requiredIfRules.requiredIfAllNotEmptyRule, errorMessage, { fields, scope: "global" });
+};
+/**
+ * Value is required if ALL specified sibling fields are NOT empty
+ */
+baseValidator.BaseValidator.prototype.requiredIfAllNotEmptySiblings = function (fields, errorMessage) {
+    return this.setRequiredRule(requiredIfRules.requiredIfAllNotEmptyRule, errorMessage, {
+        fields,
+        scope: "sibling",
+    });
+};
+/**
+ * Value is required if ANY of the specified fields is NOT empty
+ */
+baseValidator.BaseValidator.prototype.requiredIfAnyNotEmpty = function (fields, errorMessage) {
+    return this.setRequiredRule(requiredIfRules.requiredIfAnyNotEmptyRule, errorMessage, { fields, scope: "global" });
+};
+/**
+ * Value is required if ANY of the specified sibling fields is NOT empty
+ */
+baseValidator.BaseValidator.prototype.requiredIfAnyNotEmptySiblings = function (fields, errorMessage) {
+    return this.setRequiredRule(requiredIfRules.requiredIfAnyNotEmptyRule, errorMessage, {
+        fields,
+        scope: "sibling",
+    });
+};
+/**
+ * Value is required if another field's value is in the given array
+ */
+baseValidator.BaseValidator.prototype.requiredIfIn = function (field, values, errorMessage) {
+    return this.setRequiredRule(requiredIfRules.requiredIfInRule, errorMessage, { field, values, scope: "global" });
+};
+/**
+ * Value is required if another sibling field's value is in the given array
+ */
+baseValidator.BaseValidator.prototype.requiredIfInSibling = function (field, values, errorMessage) {
+    return this.setRequiredRule(requiredIfRules.requiredIfInRule, errorMessage, { field, values, scope: "sibling" });
+};
+/**
+ * Value is required if another field's value is NOT in the given array
+ */
+baseValidator.BaseValidator.prototype.requiredIfNotIn = function (field, values, errorMessage) {
+    return this.setRequiredRule(requiredIfRules.requiredIfNotInRule, errorMessage, {
+        field,
+        values,
+        scope: "global",
+    });
+};
+/**
+ * Value is required if another sibling field's value is NOT in the given array
+ */
+baseValidator.BaseValidator.prototype.requiredIfNotInSibling = function (field, values, errorMessage) {
+    return this.setRequiredRule(requiredIfRules.requiredIfNotInRule, errorMessage, {
+        field,
+        values,
+        scope: "sibling",
+    });
+};
+// ==================== REQUIRED: BASED ON MULTIPLE FIELDS (ALL) ====================
+/**
+ * Value is required if all specified fields exist
+ */
+baseValidator.BaseValidator.prototype.requiredWithAll = function (fields, errorMessage) {
+    return this.setRequiredRule(requiredWithRules.requiredWithAllRule, errorMessage, { fields, scope: "global" });
+};
+/**
+ * Value is required if all specified sibling fields exist
+ */
+baseValidator.BaseValidator.prototype.requiredWithAllSiblings = function (fields, errorMessage) {
+    return this.setRequiredRule(requiredWithRules.requiredWithAllRule, errorMessage, { fields, scope: "sibling" });
+};
+/**
+ * Value is required if all specified fields are missing
+ */
+baseValidator.BaseValidator.prototype.requiredWithoutAll = function (fields, errorMessage) {
+    return this.setRequiredRule(requiredWithoutRules.requiredWithoutAllRule, errorMessage, { fields, scope: "global" });
+};
+/**
+ * Value is required if all specified sibling fields are missing
+ */
+baseValidator.BaseValidator.prototype.requiredWithoutAllSiblings = function (fields, errorMessage) {
+    return this.setRequiredRule(requiredWithoutRules.requiredWithoutAllRule, errorMessage, { fields, scope: "sibling" });
+};
+// ==================== REQUIRED: BASED ON MULTIPLE FIELDS (ANY) ====================
+/**
+ * Value is required if any of the specified fields exists
+ */
+baseValidator.BaseValidator.prototype.requiredWithAny = function (fields, errorMessage) {
+    return this.setRequiredRule(requiredWithRules.requiredWithAnyRule, errorMessage, { fields, scope: "global" });
+};
+/**
+ * Value is required if any of the specified sibling fields exists
+ */
+baseValidator.BaseValidator.prototype.requiredWithAnySiblings = function (fields, errorMessage) {
+    return this.setRequiredRule(requiredWithRules.requiredWithAnyRule, errorMessage, { fields, scope: "sibling" });
+};
+/**
+ * Value is required if any of the specified fields is missing
+ */
+baseValidator.BaseValidator.prototype.requiredWithoutAny = function (fields, errorMessage) {
+    return this.setRequiredRule(requiredWithoutRules.requiredWithoutAnyRule, errorMessage, { fields, scope: "global" });
+};
+/**
+ * Value is required if any of the specified sibling fields is missing
+ */
+baseValidator.BaseValidator.prototype.requiredWithoutAnySiblings = function (fields, errorMessage) {
+    return this.setRequiredRule(requiredWithoutRules.requiredWithoutAnyRule, errorMessage, { fields, scope: "sibling" });
+};
+// ==================== REQUIRED: BASED ON CUSTOM CALLBACK ====================
+/**
+ * Make this field required based on a custom callback.
+ * Callback receives only SchemaContext — the framework handles empty-value checking.
+ */
+baseValidator.BaseValidator.prototype.requiredWhen = function (callback, errorMessage) {
+    return this.setRequiredRule(requiredWhenRule.requiredWhenRule, errorMessage, { callback });
+};//# sourceMappingURL=required-methods.js.map