@warlock.js/seal 5.29.0 → 5.31.0

package/esm/validators/literal-validator.mjs

@@ -1,8 +1,9 @@
 import { applyNullable } from "../standard-schema/json-schema.mjs";
+import { presentRule } from "../rules/core/required.mjs";
 import { BaseValidator } from "./base-validator.mjs";
 import { literalRule } from "../rules/common/literal.mjs";
 
-//#region ../seal/src/validators/literal-validator.ts
+//#region ../../packages/seal/src/validators/literal-validator.ts
 /**
 * Literal validator class
 *
@@ -20,9 +21,11 @@ import { literalRule } from "../rules/common/literal.mjs";
 var LiteralValidator = class extends BaseValidator {
 	constructor(values, errorMessage) {
 		super();
-		this.blankIsMissing = true;
 		this.values = values;
 		this.addMutableRule(literalRule, errorMessage, { values });
+		const acceptsBlank = values.some((value) => typeof value === "string" && value.trim() === "");
+		this.blankIsMissing = !acceptsBlank;
+		if (acceptsBlank) this.requiredRule = this.createRule(presentRule);
 	}
 	/**
 	* Check if value is one of the configured literals

package/esm/validators/literal-validator.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"literal-validator.mjs","names":[],"sources":["../../../../../../../seal/src/validators/literal-validator.ts"],"sourcesContent":["import { literalRule } from \"../rules/common/literal\";\nimport { applyNullable } from \"../standard-schema/json-schema\";\nimport type { JsonSchemaResult, JsonSchemaTarget } from \"../standard-schema/json-schema\";\nimport { BaseValidator } from \"./base-validator\";\n\n/**\n * Literal validator class\n *\n * Accepts a fixed tuple of primitive literal values (string, number, boolean).\n * The TypeScript type narrows to the union of those literals — `v.literal(\"a\", \"b\")`\n * infers as `\"a\" | \"b\"`, not `string`. Use for discriminator fields, enum-like\n * unions of constants, and any case where `oneOf([...])` would lose literal types.\n *\n * @example\n * v.literal(\"items\")               // type: \"items\"\n * v.literal(\"draft\", \"published\")  // type: \"draft\" | \"published\"\n * v.literal(1, 2, 3)               // type: 1 | 2 | 3\n * v.literal(true)                  // type: true\n */\nexport class LiteralValidator<\n  T extends readonly (string | number | boolean)[] = readonly (string | number | boolean)[],\n> extends BaseValidator {\n  public values: T;\n\n  public constructor(values: T, errorMessage?: string) {\n    super();\n    this.blankIsMissing = true;\n    this.values = values;\n    this.addMutableRule(literalRule, errorMessage, { values });\n\n    // `\"\"` is a value, not an absence. Every validator is required by default,\n    // and `required` rejects anything `isEmptyValue` calls empty — including the\n    // empty string — so `v.literal(\"\")` could never pass. When the author has\n    // explicitly listed an empty value as acceptable, swap `required` for\n    // `present`: the key must still exist, but judging the value is the literal\n    // set's job, and it is already the stricter statement of intent.\n    //\n    // Dropping the rule entirely instead would make a missing key valid, which\n    // is the opposite mistake — `alt=\"\"` and no `alt` at all are different\n    // things to a screen reader, and to anything else reading the schema.\n  }\n\n  /**\n   * Check if value is one of the configured literals\n   */\n  public matchesType(value: any): boolean {\n    return (this.values as readonly any[]).includes(value);\n  }\n\n  /**\n   * Clone the validator, preserving the literal `values` set.\n   *\n   * The base `clone()` only copies `BaseValidator` fields, so without this\n   * override a cloned literal loses its public `values` array — which breaks\n   * any consumer that reads it (e.g. `discriminatedUnion` branch routing).\n   */\n  public override clone(): this {\n    const cloned = super.clone();\n    cloned.values = this.values;\n    return cloned;\n  }\n\n  /**\n   * @inheritdoc\n   *\n   * Single literal → `{ const: <value> }`. Multiple → `{ enum: [...] }`.\n   *\n   * @example\n   * ```ts\n   * v.literal(\"items\").toJsonSchema()\n   * // → { const: \"items\" }\n   *\n   * v.literal(\"draft\", \"published\").toJsonSchema()\n   * // → { enum: [\"draft\", \"published\"] }\n   * ```\n   */\n  public override toJsonSchema(target: JsonSchemaTarget = \"draft-2020-12\"): JsonSchemaResult {\n    const schema: JsonSchemaResult =\n      this.values.length === 1 ? { const: this.values[0] } : { enum: [...this.values] };\n    if (this.isNullable) applyNullable(schema, target);\n    return schema;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAmBA,IAAa,mBAAb,cAEU,cAAc;CAGtB,AAAO,YAAY,QAAW,cAAuB;EACnD,MAAM;EACN,KAAK,iBAAiB;EACtB,KAAK,SAAS;EACd,KAAK,eAAe,aAAa,cAAc,EAAE,OAAO,CAAC;CAY3D;;;;CAKA,AAAO,YAAY,OAAqB;EACtC,OAAQ,KAAK,OAA0B,SAAS,KAAK;CACvD;;;;;;;;CASA,AAAgB,QAAc;EAC5B,MAAM,SAAS,MAAM,MAAM;EAC3B,OAAO,SAAS,KAAK;EACrB,OAAO;CACT;;;;;;;;;;;;;;;CAgBA,AAAgB,aAAa,SAA2B,iBAAmC;EACzF,MAAM,SACJ,KAAK,OAAO,WAAW,IAAI,EAAE,OAAO,KAAK,OAAO,GAAG,IAAI,EAAE,MAAM,CAAC,GAAG,KAAK,MAAM,EAAE;EAClF,IAAI,KAAK,YAAY,cAAc,QAAQ,MAAM;EACjD,OAAO;CACT;AACF"}
+{"version":3,"file":"literal-validator.mjs","names":[],"sources":["../../../../../../../../packages/seal/src/validators/literal-validator.ts"],"sourcesContent":["import { literalRule } from \"../rules/common/literal\";\nimport { presentRule } from \"../rules/core/required\";\nimport { applyNullable } from \"../standard-schema/json-schema\";\nimport type { JsonSchemaResult, JsonSchemaTarget } from \"../standard-schema/json-schema\";\nimport { BaseValidator } from \"./base-validator\";\n\n/**\n * Literal validator class\n *\n * Accepts a fixed tuple of primitive literal values (string, number, boolean).\n * The TypeScript type narrows to the union of those literals — `v.literal(\"a\", \"b\")`\n * infers as `\"a\" | \"b\"`, not `string`. Use for discriminator fields, enum-like\n * unions of constants, and any case where `oneOf([...])` would lose literal types.\n *\n * @example\n * v.literal(\"items\")               // type: \"items\"\n * v.literal(\"draft\", \"published\")  // type: \"draft\" | \"published\"\n * v.literal(1, 2, 3)               // type: 1 | 2 | 3\n * v.literal(true)                  // type: true\n */\nexport class LiteralValidator<\n  T extends readonly (string | number | boolean)[] = readonly (string | number | boolean)[],\n> extends BaseValidator {\n  public values: T;\n\n  public constructor(values: T, errorMessage?: string) {\n    super();\n    this.values = values;\n    this.addMutableRule(literalRule, errorMessage, { values });\n\n    // A blank form value counts as missing for literal/enum sets (5.25), so an\n    // unselected `<select>` reads as absent. That cannot apply when the author\n    // listed a blank string as an accepted value: there `\"\"` is a value, not an\n    // absence, and `alt=\"\"` and no `alt` at all mean different things.\n    const acceptsBlank = values.some((value) => typeof value === \"string\" && value.trim() === \"\");\n\n    this.blankIsMissing = !acceptsBlank;\n\n    // Every validator is required by default, and `required` rejects anything\n    // `isEmptyValue` calls empty, including `\"\"`. When the set accepts a blank\n    // value, swap `required` for `present`: the key must still exist, and\n    // judging the value is the literal rule's job.\n    if (acceptsBlank) {\n      this.requiredRule = this.createRule(presentRule);\n    }\n  }\n\n  /**\n   * Check if value is one of the configured literals\n   */\n  public matchesType(value: any): boolean {\n    return (this.values as readonly any[]).includes(value);\n  }\n\n  /**\n   * Clone the validator, preserving the literal `values` set.\n   *\n   * The base `clone()` only copies `BaseValidator` fields, so without this\n   * override a cloned literal loses its public `values` array — which breaks\n   * any consumer that reads it (e.g. `discriminatedUnion` branch routing).\n   */\n  public override clone(): this {\n    const cloned = super.clone();\n    cloned.values = this.values;\n    return cloned;\n  }\n\n  /**\n   * @inheritdoc\n   *\n   * Single literal → `{ const: <value> }`. Multiple → `{ enum: [...] }`.\n   *\n   * @example\n   * ```ts\n   * v.literal(\"items\").toJsonSchema()\n   * // → { const: \"items\" }\n   *\n   * v.literal(\"draft\", \"published\").toJsonSchema()\n   * // → { enum: [\"draft\", \"published\"] }\n   * ```\n   */\n  public override toJsonSchema(target: JsonSchemaTarget = \"draft-2020-12\"): JsonSchemaResult {\n    const schema: JsonSchemaResult =\n      this.values.length === 1 ? { const: this.values[0] } : { enum: [...this.values] };\n    if (this.isNullable) applyNullable(schema, target);\n    return schema;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAoBA,IAAa,mBAAb,cAEU,cAAc;CAGtB,AAAO,YAAY,QAAW,cAAuB;EACnD,MAAM;EACN,KAAK,SAAS;EACd,KAAK,eAAe,aAAa,cAAc,EAAE,OAAO,CAAC;EAMzD,MAAM,eAAe,OAAO,MAAM,UAAU,OAAO,UAAU,YAAY,MAAM,KAAK,MAAM,EAAE;EAE5F,KAAK,iBAAiB,CAAC;EAMvB,IAAI,cACF,KAAK,eAAe,KAAK,WAAW,WAAW;CAEnD;;;;CAKA,AAAO,YAAY,OAAqB;EACtC,OAAQ,KAAK,OAA0B,SAAS,KAAK;CACvD;;;;;;;;CASA,AAAgB,QAAc;EAC5B,MAAM,SAAS,MAAM,MAAM;EAC3B,OAAO,SAAS,KAAK;EACrB,OAAO;CACT;;;;;;;;;;;;;;;CAgBA,AAAgB,aAAa,SAA2B,iBAAmC;EACzF,MAAM,SACJ,KAAK,OAAO,WAAW,IAAI,EAAE,OAAO,KAAK,OAAO,GAAG,IAAI,EAAE,MAAM,CAAC,GAAG,KAAK,MAAM,EAAE;EAClF,IAAI,KAAK,YAAY,cAAc,QAAQ,MAAM;EACjD,OAAO;CACT;AACF"}

package/esm/validators/managed-validator.d.mts

@@ -2,7 +2,7 @@ import { SchemaContext } from "../types/context-types.mjs";
 import { BaseValidator } from "./base-validator.mjs";
 import { ComputedValidator } from "./computed-validator.mjs";
 
-//#region ../seal/src/validators/managed-validator.d.ts
+//#region ../../packages/seal/src/validators/managed-validator.d.ts
 /**
  * Callback function for managed fields
  * Receives only schema context (no data dependency)

package/esm/validators/managed-validator.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"managed-validator.d.mts","names":[],"sources":["../../../../../../../seal/src/validators/managed-validator.ts"],"mappings":";;;;;;;;AAQA;KAAY,eAAA,mBAAkC,OAAA,EAAS,aAAA,KAAkB,OAAA,GAAU,OAAA,CAAQ,OAAA;;;;;;;;;;;;;;;AAAO;AAsBlG;;;;;cAAa,gBAAA,wBAAwC,iBAAA,CAAkB,OAAA;EAOH;;;;;;cAAtD,QAAA,EAAU,eAAA,CAAgB,OAAA,GAAU,eAAA,GAAkB,aAAA;AAAA"}
+{"version":3,"file":"managed-validator.d.mts","names":[],"sources":["../../../../../../../../packages/seal/src/validators/managed-validator.ts"],"mappings":";;;;;;;AAQA;;KAAY,eAAA,mBAAkC,OAAA,EAAS,aAAA,KAAkB,OAAA,GAAU,OAAA,CAAQ,OAAA;;;;;;;;;;;;;;AAAO;AAsBlG;;;;;;cAAa,gBAAA,wBAAwC,iBAAA,CAAkB,OAAA;EAAlB;;;;;;cAOvC,QAAA,EAAU,eAAA,CAAgB,OAAA,GAAU,eAAA,GAAkB,aAAA;AAAA"}

package/esm/validators/managed-validator.mjs

@@ -1,6 +1,6 @@
 import { ComputedValidator } from "./computed-validator.mjs";
 
-//#region ../seal/src/validators/managed-validator.ts
+//#region ../../packages/seal/src/validators/managed-validator.ts
 /**
 * Managed field validator
 *

package/esm/validators/managed-validator.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"managed-validator.mjs","names":[],"sources":["../../../../../../../seal/src/validators/managed-validator.ts"],"sourcesContent":["import type { SchemaContext } from \"../types\";\nimport type { BaseValidator } from \"./base-validator\";\nimport { ComputedValidator, type ComputedCallback } from \"./computed-validator\";\n\n/**\n * Callback function for managed fields\n * Receives only schema context (no data dependency)\n */\nexport type ManagedCallback<TResult = any> = (context: SchemaContext) => TResult | Promise<TResult>;\n\n/**\n * Managed field validator\n *\n * The callback is optional - if not provided, the framework can inject the value.\n * @example\n * ```ts\n * // With callback (framework executes it)\n * const schema = v.object({\n *   name: v.string(),\n *   createdAt: v.managed(() => new Date()),\n *   updatedAt: v.managed(() => new Date()),\n * });\n *\n * // Without callback (framework injects value)\n * const schema = v.object({\n *   name: v.string(),\n *   id: v.managed(() => 1),\n * });\n * ```\n */\nexport class ManagedValidator<TResult = any> extends ComputedValidator<TResult> {\n  /**\n   * Create a new managed field validator\n   *\n   * @param callback - Optional function to generate the value\n   * @param resultValidator - Optional validator to validate the generated result\n   */\n  constructor(callback: ManagedCallback<TResult>, resultValidator?: BaseValidator) {\n    // Convert ManagedCallback to ComputedCallback\n    // Managed callbacks don't receive data, only context\n    const computedCallback: ComputedCallback<TResult> = (_data, context) => callback(context);\n\n    super(computedCallback, resultValidator);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AA8BA,IAAa,mBAAb,cAAqD,kBAA2B;;;;;;;CAO9E,YAAY,UAAoC,iBAAiC;EAG/E,MAAM,oBAA+C,OAAO,YAAY,SAAS,OAAO;EAExF,MAAM,kBAAkB,eAAe;CACzC;AACF"}
+{"version":3,"file":"managed-validator.mjs","names":[],"sources":["../../../../../../../../packages/seal/src/validators/managed-validator.ts"],"sourcesContent":["import type { SchemaContext } from \"../types\";\nimport type { BaseValidator } from \"./base-validator\";\nimport { ComputedValidator, type ComputedCallback } from \"./computed-validator\";\n\n/**\n * Callback function for managed fields\n * Receives only schema context (no data dependency)\n */\nexport type ManagedCallback<TResult = any> = (context: SchemaContext) => TResult | Promise<TResult>;\n\n/**\n * Managed field validator\n *\n * The callback is optional - if not provided, the framework can inject the value.\n * @example\n * ```ts\n * // With callback (framework executes it)\n * const schema = v.object({\n *   name: v.string(),\n *   createdAt: v.managed(() => new Date()),\n *   updatedAt: v.managed(() => new Date()),\n * });\n *\n * // Without callback (framework injects value)\n * const schema = v.object({\n *   name: v.string(),\n *   id: v.managed(() => 1),\n * });\n * ```\n */\nexport class ManagedValidator<TResult = any> extends ComputedValidator<TResult> {\n  /**\n   * Create a new managed field validator\n   *\n   * @param callback - Optional function to generate the value\n   * @param resultValidator - Optional validator to validate the generated result\n   */\n  constructor(callback: ManagedCallback<TResult>, resultValidator?: BaseValidator) {\n    // Convert ManagedCallback to ComputedCallback\n    // Managed callbacks don't receive data, only context\n    const computedCallback: ComputedCallback<TResult> = (_data, context) => callback(context);\n\n    super(computedCallback, resultValidator);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AA8BA,IAAa,mBAAb,cAAqD,kBAA2B;;;;;;;CAO9E,YAAY,UAAoC,iBAAiC;EAG/E,MAAM,oBAA+C,OAAO,YAAY,SAAS,OAAO;EAExF,MAAM,kBAAkB,eAAe;CACzC;AACF"}

package/esm/validators/methods/equality-conditional-methods.d.mts

@@ -1,5 +1,6 @@
 import { WhenRuleOptions } from "../../types/conditional-types.mjs";
-//#region ../seal/src/validators/methods/equality-conditional-methods.d.ts
+
+//#region ../../packages/seal/src/validators/methods/equality-conditional-methods.d.ts
 /**
  * Marker re-exported by the validators barrel so the dts bundler keeps this
  * module (and its `declare module` augmentation) in the bundled `.d.ts`.

package/esm/validators/methods/equality-conditional-methods.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"equality-conditional-methods.d.mts","names":[],"sources":["../../../../../../../../seal/src/validators/methods/equality-conditional-methods.ts"],"mappings":";;;;;AAUA;cAAa,iCAAA;AAAA;EAAA,UAGD,aAAA;IAHkC;AAAQ;;IAOlD,KAAA,CAAM,KAAA,OAAY,YAAA;IA0DgB;;;IArDlC,MAAA,CAAO,KAAA,UAAe,YAAA;IA+EyB;;;IA1E/C,aAAA,CAAc,KAAA,UAAe,YAAA;IAVvB;;;IAeN,aAAA,CAAc,KAAA,UAAe,YAAA;IAVP;;;IAetB,oBAAA,CAAqB,KAAA,UAAe,YAAA;IALpC;;;;;;;;;;;;;;;;;;AAqEmF;;;;;;;;;;;;;;;;;;IA1BnF,IAAA,CAAK,KAAA,UAAe,OAAA,EAAS,IAAA,CAAK,eAAA;;;;;;;;;;;;;;;;;;;;;;;;;IA0BlC,WAAA,CAAY,YAAA,UAAsB,OAAA,EAAS,IAAA,CAAK,eAAA;EAAA;AAAA"}
+{"version":3,"file":"equality-conditional-methods.d.mts","names":[],"sources":["../../../../../../../../../packages/seal/src/validators/methods/equality-conditional-methods.ts"],"mappings":";;;;;AAUA;;cAAa,iCAAA;AAAA;EAAA,UAGD,aAAA;IAH0C;;;IAOlD,KAAA,CAAM,KAAA,OAAY,YAAA;IA0DW;;;IArD7B,MAAA,CAAO,KAAA,UAAe,YAAA;IA+EyB;;;IA1E/C,aAAA,CAAc,KAAA,UAAe,YAAA;IAVX;;;IAelB,aAAA,CAAc,KAAA,UAAe,YAAA;IAL7B;;;IAUA,oBAAA,CAAqB,KAAA,UAAe,YAAA;IALtB;;;;;;;;;;;;;;;;;AAqEqE;;;;;;;;;;;;;;;;;;;IA1BnF,IAAA,CAAK,KAAA,UAAe,OAAA,EAAS,IAAA,CAAK,eAAA;;;;;;;;;;;;;;;;;;;;;;;;;IA0BlC,WAAA,CAAY,YAAA,UAAsB,OAAA,EAAS,IAAA,CAAK,eAAA;EAAA;AAAA"}

package/esm/validators/methods/equality-conditional-methods.mjs

@@ -4,7 +4,7 @@ import { whenRule } from "../../rules/core/when.mjs";
 import { equalsFieldRule, notEqualsFieldRule } from "../../rules/common/equals-field-rules.mjs";
 import "../../rules/index.mjs";
 
-//#region ../seal/src/validators/methods/equality-conditional-methods.ts
+//#region ../../packages/seal/src/validators/methods/equality-conditional-methods.ts
 /**
 * Marker re-exported by the validators barrel so the dts bundler keeps this
 * module (and its `declare module` augmentation) in the bundled `.d.ts`.

package/esm/validators/methods/equality-conditional-methods.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"equality-conditional-methods.mjs","names":[],"sources":["../../../../../../../../seal/src/validators/methods/equality-conditional-methods.ts"],"sourcesContent":["import { equalsFieldRule, notEqualsFieldRule } from \"../../rules\";\nimport { equalRule } from \"../../rules/core/equal\";\nimport { whenRule } from \"../../rules/core/when\";\nimport type { WhenRuleOptions } from \"../../types\";\nimport { BaseValidator } from \"../base-validator\";\n\n/**\n * Marker re-exported by the validators barrel so the dts bundler keeps this\n * module (and its `declare module` augmentation) in the bundled `.d.ts`.\n */\nexport const equalityConditionalMethodsApplied = true;\n\ndeclare module \"../base-validator\" {\n  interface BaseValidator {\n    /**\n     * Value must be equal to the given value\n     */\n    equal(value: any, errorMessage?: string): this;\n\n    /**\n     * Value must be the same as another field's value\n     */\n    sameAs(field: string, errorMessage?: string): this;\n\n    /**\n     * Value must be the same as another sibling field's value\n     */\n    sameAsSibling(field: string, errorMessage?: string): this;\n\n    /**\n     * Value must be different from another field's value\n     */\n    differentFrom(field: string, errorMessage?: string): this;\n\n    /**\n     * Value must be different from another sibling field's value\n     */\n    differentFromSibling(field: string, errorMessage?: string): this;\n\n    /**\n     * Apply different validation rules based on another field's value (global scope)\n     *\n     * Use this when you need to apply completely different validators\n     * based on another field's value (not just required/optional).\n     *\n     * @param field - Field name to check (can be nested with dot notation)\n     * @param options - Validation options per field value\n     *\n     * @example\n     * ```ts\n     * // Different allowed values based on user type\n     * v.object({\n     *   userType: v.string().in(['admin', 'user']),\n     *   role: v.string().when('userType', {\n     *     is: {\n     *       admin: v.string().in(['super', 'moderator']),\n     *       user: v.string().in(['member', 'guest'])\n     *     },\n     *     otherwise: v.string().optional()\n     *   })\n     * })\n     *\n     * // Different validation rules based on type\n     * v.object({\n     *   contactType: v.string().in(['email', 'phone']),\n     *   contact: v.string().when('contactType', {\n     *     is: {\n     *       email: v.string().email(),\n     *       phone: v.string().pattern(/^\\d{10}$/)\n     *     }\n     *   })\n     * })\n     * ```\n     * @category Conditional Validation\n     */\n    when(field: string, options: Omit<WhenRuleOptions, \"field\" | \"scope\">): this;\n\n    /**\n     * Apply different validation rules based on sibling field's value\n     *\n     * Use this for nested objects where you need to check a field\n     * within the same parent object.\n     *\n     * @param siblingField - Sibling field name to check\n     * @param options - Validation options per field value\n     *\n     * @example\n     * ```ts\n     * // Array of users with role-based permissions\n     * v.array(v.object({\n     *   userType: v.string().in(['admin', 'user']),\n     *   permissions: v.string().whenSibling('userType', {\n     *     is: {\n     *       admin: v.string().in(['read', 'write', 'delete']),\n     *       user: v.string().in(['read'])\n     *     }\n     *   })\n     * }))\n     * ```\n     * @category Conditional Validation\n     */\n    whenSibling(siblingField: string, options: Omit<WhenRuleOptions, \"field\" | \"scope\">): this;\n  }\n}\n\n/**\n * Value must be equal to the given value\n */\nBaseValidator.prototype.equal = function (value: any, errorMessage?: string) {\n  return this.addRule(equalRule, errorMessage, { value });\n};\n\n/**\n * Value must be the same as another field's value\n */\nBaseValidator.prototype.sameAs = function (field: string, errorMessage?: string) {\n  return this.addRule(equalsFieldRule, errorMessage, {\n    field,\n    scope: \"global\",\n  });\n};\n\n/**\n * Value must be the same as another sibling field's value\n */\nBaseValidator.prototype.sameAsSibling = function (field: string, errorMessage?: string) {\n  return this.addRule(equalsFieldRule, errorMessage, {\n    field,\n    scope: \"sibling\",\n  });\n};\n\n/**\n * Value must be different from another field's value\n */\nBaseValidator.prototype.differentFrom = function (field: string, errorMessage?: string) {\n  return this.addRule(notEqualsFieldRule, errorMessage, {\n    field,\n    scope: \"global\",\n  });\n};\n\n/**\n * Value must be different from another sibling field's value\n */\nBaseValidator.prototype.differentFromSibling = function (field: string, errorMessage?: string) {\n  return this.addRule(notEqualsFieldRule, errorMessage, {\n    field,\n    scope: \"sibling\",\n  });\n};\n\n/**\n * Apply different validation rules based on another field's value (global scope)\n *\n * Use this when you need to apply completely different validators\n * based on another field's value (not just required/optional).\n *\n * @param field - Field name to check (can be nested with dot notation)\n * @param options - Validation options per field value\n *\n * @example\n * ```ts\n * // Different allowed values based on user type\n * v.object({\n *   userType: v.string().in(['admin', 'user']),\n *   role: v.string().when('userType', {\n *     is: {\n *       admin: v.string().in(['super', 'moderator']),\n *       user: v.string().in(['member', 'guest'])\n *     },\n *     otherwise: v.string().optional()\n *   })\n * })\n *\n * // Different validation rules based on type\n * v.object({\n *   contactType: v.string().in(['email', 'phone']),\n *   contact: v.string().when('contactType', {\n *     is: {\n *       email: v.string().email(),\n *       phone: v.string().pattern(/^\\d{10}$/)\n *     }\n *   })\n * })\n * ```\n * @category Conditional Validation\n */\nBaseValidator.prototype.when = function (\n  field: string,\n  options: Omit<WhenRuleOptions, \"field\" | \"scope\">,\n) {\n  return this.addRule(whenRule, undefined, {\n    field,\n    is: options.is,\n    otherwise: options.otherwise,\n    scope: \"global\",\n  });\n};\n\n/**\n * Apply different validation rules based on sibling field's value\n *\n * Use this for nested objects where you need to check a field\n * within the same parent object.\n *\n * @param siblingField - Sibling field name to check\n * @param options - Validation options per field value\n *\n * @example\n * ```ts\n * // Array of users with role-based permissions\n * v.array(v.object({\n *   userType: v.string().in(['admin', 'user']),\n *   permissions: v.string().whenSibling('userType', {\n *     is: {\n *       admin: v.string().in(['read', 'write', 'delete']),\n *       user: v.string().in(['read'])\n *     }\n *   })\n * }))\n * ```\n * @category Conditional Validation\n */\nBaseValidator.prototype.whenSibling = function (\n  siblingField: string,\n  options: Omit<WhenRuleOptions, \"field\" | \"scope\">,\n) {\n  return this.addRule(whenRule, undefined, {\n    field: siblingField,\n    is: options.is,\n    otherwise: options.otherwise,\n    scope: \"sibling\",\n  });\n};\n"],"mappings":";;;;;;;;;;;AAUA,MAAa,oCAAoC;;;;AAkGjD,cAAc,UAAU,QAAQ,SAAU,OAAY,cAAuB;CAC3E,OAAO,KAAK,QAAQ,WAAW,cAAc,EAAE,MAAM,CAAC;AACxD;;;;AAKA,cAAc,UAAU,SAAS,SAAU,OAAe,cAAuB;CAC/E,OAAO,KAAK,QAAQ,iBAAiB,cAAc;EACjD;EACA,OAAO;CACT,CAAC;AACH;;;;AAKA,cAAc,UAAU,gBAAgB,SAAU,OAAe,cAAuB;CACtF,OAAO,KAAK,QAAQ,iBAAiB,cAAc;EACjD;EACA,OAAO;CACT,CAAC;AACH;;;;AAKA,cAAc,UAAU,gBAAgB,SAAU,OAAe,cAAuB;CACtF,OAAO,KAAK,QAAQ,oBAAoB,cAAc;EACpD;EACA,OAAO;CACT,CAAC;AACH;;;;AAKA,cAAc,UAAU,uBAAuB,SAAU,OAAe,cAAuB;CAC7F,OAAO,KAAK,QAAQ,oBAAoB,cAAc;EACpD;EACA,OAAO;CACT,CAAC;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCA,cAAc,UAAU,OAAO,SAC7B,OACA,SACA;CACA,OAAO,KAAK,QAAQ,UAAU,QAAW;EACvC;EACA,IAAI,QAAQ;EACZ,WAAW,QAAQ;EACnB,OAAO;CACT,CAAC;AACH;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,cAAc,UAAU,cAAc,SACpC,cACA,SACA;CACA,OAAO,KAAK,QAAQ,UAAU,QAAW;EACvC,OAAO;EACP,IAAI,QAAQ;EACZ,WAAW,QAAQ;EACnB,OAAO;CACT,CAAC;AACH"}
+{"version":3,"file":"equality-conditional-methods.mjs","names":[],"sources":["../../../../../../../../../packages/seal/src/validators/methods/equality-conditional-methods.ts"],"sourcesContent":["import { equalsFieldRule, notEqualsFieldRule } from \"../../rules\";\nimport { equalRule } from \"../../rules/core/equal\";\nimport { whenRule } from \"../../rules/core/when\";\nimport type { WhenRuleOptions } from \"../../types\";\nimport { BaseValidator } from \"../base-validator\";\n\n/**\n * Marker re-exported by the validators barrel so the dts bundler keeps this\n * module (and its `declare module` augmentation) in the bundled `.d.ts`.\n */\nexport const equalityConditionalMethodsApplied = true;\n\ndeclare module \"../base-validator\" {\n  interface BaseValidator {\n    /**\n     * Value must be equal to the given value\n     */\n    equal(value: any, errorMessage?: string): this;\n\n    /**\n     * Value must be the same as another field's value\n     */\n    sameAs(field: string, errorMessage?: string): this;\n\n    /**\n     * Value must be the same as another sibling field's value\n     */\n    sameAsSibling(field: string, errorMessage?: string): this;\n\n    /**\n     * Value must be different from another field's value\n     */\n    differentFrom(field: string, errorMessage?: string): this;\n\n    /**\n     * Value must be different from another sibling field's value\n     */\n    differentFromSibling(field: string, errorMessage?: string): this;\n\n    /**\n     * Apply different validation rules based on another field's value (global scope)\n     *\n     * Use this when you need to apply completely different validators\n     * based on another field's value (not just required/optional).\n     *\n     * @param field - Field name to check (can be nested with dot notation)\n     * @param options - Validation options per field value\n     *\n     * @example\n     * ```ts\n     * // Different allowed values based on user type\n     * v.object({\n     *   userType: v.string().in(['admin', 'user']),\n     *   role: v.string().when('userType', {\n     *     is: {\n     *       admin: v.string().in(['super', 'moderator']),\n     *       user: v.string().in(['member', 'guest'])\n     *     },\n     *     otherwise: v.string().optional()\n     *   })\n     * })\n     *\n     * // Different validation rules based on type\n     * v.object({\n     *   contactType: v.string().in(['email', 'phone']),\n     *   contact: v.string().when('contactType', {\n     *     is: {\n     *       email: v.string().email(),\n     *       phone: v.string().pattern(/^\\d{10}$/)\n     *     }\n     *   })\n     * })\n     * ```\n     * @category Conditional Validation\n     */\n    when(field: string, options: Omit<WhenRuleOptions, \"field\" | \"scope\">): this;\n\n    /**\n     * Apply different validation rules based on sibling field's value\n     *\n     * Use this for nested objects where you need to check a field\n     * within the same parent object.\n     *\n     * @param siblingField - Sibling field name to check\n     * @param options - Validation options per field value\n     *\n     * @example\n     * ```ts\n     * // Array of users with role-based permissions\n     * v.array(v.object({\n     *   userType: v.string().in(['admin', 'user']),\n     *   permissions: v.string().whenSibling('userType', {\n     *     is: {\n     *       admin: v.string().in(['read', 'write', 'delete']),\n     *       user: v.string().in(['read'])\n     *     }\n     *   })\n     * }))\n     * ```\n     * @category Conditional Validation\n     */\n    whenSibling(siblingField: string, options: Omit<WhenRuleOptions, \"field\" | \"scope\">): this;\n  }\n}\n\n/**\n * Value must be equal to the given value\n */\nBaseValidator.prototype.equal = function (value: any, errorMessage?: string) {\n  return this.addRule(equalRule, errorMessage, { value });\n};\n\n/**\n * Value must be the same as another field's value\n */\nBaseValidator.prototype.sameAs = function (field: string, errorMessage?: string) {\n  return this.addRule(equalsFieldRule, errorMessage, {\n    field,\n    scope: \"global\",\n  });\n};\n\n/**\n * Value must be the same as another sibling field's value\n */\nBaseValidator.prototype.sameAsSibling = function (field: string, errorMessage?: string) {\n  return this.addRule(equalsFieldRule, errorMessage, {\n    field,\n    scope: \"sibling\",\n  });\n};\n\n/**\n * Value must be different from another field's value\n */\nBaseValidator.prototype.differentFrom = function (field: string, errorMessage?: string) {\n  return this.addRule(notEqualsFieldRule, errorMessage, {\n    field,\n    scope: \"global\",\n  });\n};\n\n/**\n * Value must be different from another sibling field's value\n */\nBaseValidator.prototype.differentFromSibling = function (field: string, errorMessage?: string) {\n  return this.addRule(notEqualsFieldRule, errorMessage, {\n    field,\n    scope: \"sibling\",\n  });\n};\n\n/**\n * Apply different validation rules based on another field's value (global scope)\n *\n * Use this when you need to apply completely different validators\n * based on another field's value (not just required/optional).\n *\n * @param field - Field name to check (can be nested with dot notation)\n * @param options - Validation options per field value\n *\n * @example\n * ```ts\n * // Different allowed values based on user type\n * v.object({\n *   userType: v.string().in(['admin', 'user']),\n *   role: v.string().when('userType', {\n *     is: {\n *       admin: v.string().in(['super', 'moderator']),\n *       user: v.string().in(['member', 'guest'])\n *     },\n *     otherwise: v.string().optional()\n *   })\n * })\n *\n * // Different validation rules based on type\n * v.object({\n *   contactType: v.string().in(['email', 'phone']),\n *   contact: v.string().when('contactType', {\n *     is: {\n *       email: v.string().email(),\n *       phone: v.string().pattern(/^\\d{10}$/)\n *     }\n *   })\n * })\n * ```\n * @category Conditional Validation\n */\nBaseValidator.prototype.when = function (\n  field: string,\n  options: Omit<WhenRuleOptions, \"field\" | \"scope\">,\n) {\n  return this.addRule(whenRule, undefined, {\n    field,\n    is: options.is,\n    otherwise: options.otherwise,\n    scope: \"global\",\n  });\n};\n\n/**\n * Apply different validation rules based on sibling field's value\n *\n * Use this for nested objects where you need to check a field\n * within the same parent object.\n *\n * @param siblingField - Sibling field name to check\n * @param options - Validation options per field value\n *\n * @example\n * ```ts\n * // Array of users with role-based permissions\n * v.array(v.object({\n *   userType: v.string().in(['admin', 'user']),\n *   permissions: v.string().whenSibling('userType', {\n *     is: {\n *       admin: v.string().in(['read', 'write', 'delete']),\n *       user: v.string().in(['read'])\n *     }\n *   })\n * }))\n * ```\n * @category Conditional Validation\n */\nBaseValidator.prototype.whenSibling = function (\n  siblingField: string,\n  options: Omit<WhenRuleOptions, \"field\" | \"scope\">,\n) {\n  return this.addRule(whenRule, undefined, {\n    field: siblingField,\n    is: options.is,\n    otherwise: options.otherwise,\n    scope: \"sibling\",\n  });\n};\n"],"mappings":";;;;;;;;;;;AAUA,MAAa,oCAAoC;;;;AAkGjD,cAAc,UAAU,QAAQ,SAAU,OAAY,cAAuB;CAC3E,OAAO,KAAK,QAAQ,WAAW,cAAc,EAAE,MAAM,CAAC;AACxD;;;;AAKA,cAAc,UAAU,SAAS,SAAU,OAAe,cAAuB;CAC/E,OAAO,KAAK,QAAQ,iBAAiB,cAAc;EACjD;EACA,OAAO;CACT,CAAC;AACH;;;;AAKA,cAAc,UAAU,gBAAgB,SAAU,OAAe,cAAuB;CACtF,OAAO,KAAK,QAAQ,iBAAiB,cAAc;EACjD;EACA,OAAO;CACT,CAAC;AACH;;;;AAKA,cAAc,UAAU,gBAAgB,SAAU,OAAe,cAAuB;CACtF,OAAO,KAAK,QAAQ,oBAAoB,cAAc;EACpD;EACA,OAAO;CACT,CAAC;AACH;;;;AAKA,cAAc,UAAU,uBAAuB,SAAU,OAAe,cAAuB;CAC7F,OAAO,KAAK,QAAQ,oBAAoB,cAAc;EACpD;EACA,OAAO;CACT,CAAC;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCA,cAAc,UAAU,OAAO,SAC7B,OACA,SACA;CACA,OAAO,KAAK,QAAQ,UAAU,QAAW;EACvC;EACA,IAAI,QAAQ;EACZ,WAAW,QAAQ;EACnB,OAAO;CACT,CAAC;AACH;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,cAAc,UAAU,cAAc,SACpC,cACA,SACA;CACA,OAAO,KAAK,QAAQ,UAAU,QAAW;EACvC,OAAO;EACP,IAAI,QAAQ;EACZ,WAAW,QAAQ;EACnB,OAAO;CACT,CAAC;AACH"}

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

@@ -1,4 +1,4 @@
-//#region ../seal/src/validators/methods/forbidden-methods.d.ts
+//#region ../../packages/seal/src/validators/methods/forbidden-methods.d.ts
 /**
  * Marker re-exported by the validators barrel so the dts bundler keeps this
  * module (and its `declare module` augmentation) in the bundled `.d.ts`.

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

@@ -1 +1 @@
-{"version":3,"file":"forbidden-methods.d.mts","names":[],"sources":["../../../../../../../../seal/src/validators/methods/forbidden-methods.ts"],"mappings":";;AAeA;;;cAAa,uBAAA;AAAA;EAAA,UAGD,aAAA;IAHgC;;;IAOxC,SAAA,CAAU,YAAA;IAAV;;;IAKA,WAAA,CAAY,KAAA,UAAe,KAAA,OAAY,YAAA;IAAZ;;;IAK3B,kBAAA,CAAmB,KAAA,UAAe,KAAA,OAAY,YAAA;IAAZ;;;IAKlC,cAAA,CAAe,KAAA,UAAe,KAAA,OAAY,YAAA;IAAZ;;;IAK9B,qBAAA,CAAsB,KAAA,UAAe,KAAA,OAAY,YAAA;IAAZ;;;IAKrC,gBAAA,CAAiB,KAAA,UAAe,YAAA;IAAA;;;IAKhC,uBAAA,CAAwB,KAAA,UAAe,YAAA;IAKvC;;;IAAA,mBAAA,CAAoB,KAAA,UAAe,YAAA;IAKR;;;IAA3B,0BAAA,CAA2B,KAAA,UAAe,YAAA;IAKb;;;IAA7B,aAAA,CAAc,KAAA,UAAe,MAAA,SAAe,YAAA;IAKR;;;IAApC,oBAAA,CAAqB,KAAA,UAAe,MAAA,SAAe,YAAA;IAKnB;;;IAAhC,gBAAA,CAAiB,KAAA,UAAe,MAAA,SAAe,YAAA;IAKR;;;IAAvC,uBAAA,CAAwB,KAAA,UAAe,MAAA,SAAe,YAAA;EAAA;AAAA"}
+{"version":3,"file":"forbidden-methods.d.mts","names":[],"sources":["../../../../../../../../../packages/seal/src/validators/methods/forbidden-methods.ts"],"mappings":";;AAeA;;;cAAa,uBAAA;AAAA;EAAA,UAGD,aAAA;IAHgC;;;IAOxC,SAAA,CAAU,YAAA;IAAV;;;IAKA,WAAA,CAAY,KAAA,UAAe,KAAA,OAAY,YAAA;IAAZ;;;IAK3B,kBAAA,CAAmB,KAAA,UAAe,KAAA,OAAY,YAAA;IAAZ;;;IAKlC,cAAA,CAAe,KAAA,UAAe,KAAA,OAAY,YAAA;IAAZ;;;IAK9B,qBAAA,CAAsB,KAAA,UAAe,KAAA,OAAY,YAAA;IAAZ;;;IAKrC,gBAAA,CAAiB,KAAA,UAAe,YAAA;IAAA;;;IAKhC,uBAAA,CAAwB,KAAA,UAAe,YAAA;IAKvC;;;IAAA,mBAAA,CAAoB,KAAA,UAAe,YAAA;IAKR;;;IAA3B,0BAAA,CAA2B,KAAA,UAAe,YAAA;IAKb;;;IAA7B,aAAA,CAAc,KAAA,UAAe,MAAA,SAAe,YAAA;IAKR;;;IAApC,oBAAA,CAAqB,KAAA,UAAe,MAAA,SAAe,YAAA;IAKnB;;;IAAhC,gBAAA,CAAiB,KAAA,UAAe,MAAA,SAAe,YAAA;IAKR;;;IAAvC,uBAAA,CAAwB,KAAA,UAAe,MAAA,SAAe,YAAA;EAAA;AAAA"}

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

@@ -2,7 +2,7 @@ import { BaseValidator } from "../base-validator.mjs";
 import { forbiddenRule } from "../../rules/core/forbidden.mjs";
 import { forbiddenIfEmptyRule, forbiddenIfInRule, forbiddenIfNotEmptyRule, forbiddenIfNotInRule, forbiddenIfNotRule, forbiddenIfRule } from "../../rules/conditional/forbidden-if-rules.mjs";
 
-//#region ../seal/src/validators/methods/forbidden-methods.ts
+//#region ../../packages/seal/src/validators/methods/forbidden-methods.ts
 /**
 * Marker re-exported by the validators barrel so the dts bundler keeps this
 * module (and its `declare module` augmentation) in the bundled `.d.ts`.

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

@@ -1 +1 @@
-{"version":3,"file":"forbidden-methods.mjs","names":[],"sources":["../../../../../../../../seal/src/validators/methods/forbidden-methods.ts"],"sourcesContent":["import {\n  forbiddenIfEmptyRule,\n  forbiddenIfInRule,\n  forbiddenIfNotEmptyRule,\n  forbiddenIfNotInRule,\n  forbiddenIfNotRule,\n  forbiddenIfRule,\n} from \"../../rules/conditional/forbidden-if-rules\";\nimport { forbiddenRule } from \"../../rules/core/forbidden\";\nimport { BaseValidator } from \"../base-validator\";\n\n/**\n * Marker re-exported by the validators barrel so the dts bundler keeps this\n * module (and its `declare module` augmentation) in the bundled `.d.ts`.\n */\nexport const forbiddenMethodsApplied = true;\n\ndeclare module \"../base-validator\" {\n  interface BaseValidator {\n    /**\n     * Value is forbidden to be present\n     */\n    forbidden(errorMessage?: string): this;\n\n    /**\n     * Value is forbidden if another field equals a specific value (global scope)\n     */\n    forbiddenIf(field: string, value: any, errorMessage?: string): this;\n\n    /**\n     * Value is forbidden if another field equals a specific value (sibling scope)\n     */\n    forbiddenIfSibling(field: string, value: any, errorMessage?: string): this;\n\n    /**\n     * Value is forbidden if another field does NOT equal a specific value (global scope)\n     */\n    forbiddenIfNot(field: string, value: any, errorMessage?: string): this;\n\n    /**\n     * Value is forbidden if another field does NOT equal a specific value (sibling scope)\n     */\n    forbiddenIfNotSibling(field: string, value: any, errorMessage?: string): this;\n\n    /**\n     * Value is forbidden if another field is empty (global scope)\n     */\n    forbiddenIfEmpty(field: string, errorMessage?: string): this;\n\n    /**\n     * Value is forbidden if another field is empty (sibling scope)\n     */\n    forbiddenIfEmptySibling(field: string, errorMessage?: string): this;\n\n    /**\n     * Value is forbidden if another field is not empty (global scope)\n     */\n    forbiddenIfNotEmpty(field: string, errorMessage?: string): this;\n\n    /**\n     * Value is forbidden if another field is not empty (sibling scope)\n     */\n    forbiddenIfNotEmptySibling(field: string, errorMessage?: string): this;\n\n    /**\n     * Value is forbidden if another field's value is in the given array (global scope)\n     */\n    forbiddenIfIn(field: string, values: any[], errorMessage?: string): this;\n\n    /**\n     * Value is forbidden if another field's value is in the given array (sibling scope)\n     */\n    forbiddenIfInSibling(field: string, values: any[], errorMessage?: string): this;\n\n    /**\n     * Value is forbidden if another field's value is NOT in the given array (global scope)\n     */\n    forbiddenIfNotIn(field: string, values: any[], errorMessage?: string): this;\n\n    /**\n     * Value is forbidden if another field's value is NOT in the given array (sibling scope)\n     */\n    forbiddenIfNotInSibling(field: string, values: any[], errorMessage?: string): this;\n  }\n}\n\n/**\n * Value is forbidden to be present\n */\nBaseValidator.prototype.forbidden = function (errorMessage?: string) {\n  return this.addRule(forbiddenRule, errorMessage);\n};\n\n/**\n * Value is forbidden if another field equals a specific value (global scope)\n */\nBaseValidator.prototype.forbiddenIf = function (field: string, value: any, errorMessage?: string) {\n  return this.addRule(forbiddenIfRule, errorMessage, {\n    field,\n    value,\n    scope: \"global\",\n  });\n};\n\n/**\n * Value is forbidden if another field equals a specific value (sibling scope)\n */\nBaseValidator.prototype.forbiddenIfSibling = function (\n  field: string,\n  value: any,\n  errorMessage?: string,\n) {\n  return this.addRule(forbiddenIfRule, errorMessage, {\n    field,\n    value,\n    scope: \"sibling\",\n  });\n};\n\n/**\n * Value is forbidden if another field does NOT equal a specific value (global scope)\n */\nBaseValidator.prototype.forbiddenIfNot = function (\n  field: string,\n  value: any,\n  errorMessage?: string,\n) {\n  return this.addRule(forbiddenIfNotRule, errorMessage, {\n    field,\n    value,\n    scope: \"global\",\n  });\n};\n\n/**\n * Value is forbidden if another field does NOT equal a specific value (sibling scope)\n */\nBaseValidator.prototype.forbiddenIfNotSibling = function (\n  field: string,\n  value: any,\n  errorMessage?: string,\n) {\n  return this.addRule(forbiddenIfNotRule, errorMessage, {\n    field,\n    value,\n    scope: \"sibling\",\n  });\n};\n\n/**\n * Value is forbidden if another field is empty (global scope)\n */\nBaseValidator.prototype.forbiddenIfEmpty = function (field: string, errorMessage?: string) {\n  return this.addRule(forbiddenIfEmptyRule, errorMessage, {\n    field,\n    scope: \"global\",\n  });\n};\n\n/**\n * Value is forbidden if another field is empty (sibling scope)\n */\nBaseValidator.prototype.forbiddenIfEmptySibling = function (field: string, errorMessage?: string) {\n  return this.addRule(forbiddenIfEmptyRule, errorMessage, {\n    field,\n    scope: \"sibling\",\n  });\n};\n\n/**\n * Value is forbidden if another field is not empty (global scope)\n */\nBaseValidator.prototype.forbiddenIfNotEmpty = function (field: string, errorMessage?: string) {\n  return this.addRule(forbiddenIfNotEmptyRule, errorMessage, {\n    field,\n    scope: \"global\",\n  });\n};\n\n/**\n * Value is forbidden if another field is not empty (sibling scope)\n */\nBaseValidator.prototype.forbiddenIfNotEmptySibling = function (\n  field: string,\n  errorMessage?: string,\n) {\n  return this.addRule(forbiddenIfNotEmptyRule, errorMessage, {\n    field,\n    scope: \"sibling\",\n  });\n};\n\n/**\n * Value is forbidden if another field's value is in the given array (global scope)\n */\nBaseValidator.prototype.forbiddenIfIn = function (\n  field: string,\n  values: any[],\n  errorMessage?: string,\n) {\n  return this.addRule(forbiddenIfInRule, errorMessage, {\n    field,\n    values,\n    scope: \"global\",\n  });\n};\n\n/**\n * Value is forbidden if another field's value is in the given array (sibling scope)\n */\nBaseValidator.prototype.forbiddenIfInSibling = function (\n  field: string,\n  values: any[],\n  errorMessage?: string,\n) {\n  return this.addRule(forbiddenIfInRule, errorMessage, {\n    field,\n    values,\n    scope: \"sibling\",\n  });\n};\n\n/**\n * Value is forbidden if another field's value is NOT in the given array (global scope)\n */\nBaseValidator.prototype.forbiddenIfNotIn = function (\n  field: string,\n  values: any[],\n  errorMessage?: string,\n) {\n  return this.addRule(forbiddenIfNotInRule, errorMessage, {\n    field,\n    values,\n    scope: \"global\",\n  });\n};\n\n/**\n * Value is forbidden if another field's value is NOT in the given array (sibling scope)\n */\nBaseValidator.prototype.forbiddenIfNotInSibling = function (\n  field: string,\n  values: any[],\n  errorMessage?: string,\n) {\n  return this.addRule(forbiddenIfNotInRule, errorMessage, {\n    field,\n    values,\n    scope: \"sibling\",\n  });\n};\n"],"mappings":";;;;;;;;;AAeA,MAAa,0BAA0B;;;;AA0EvC,cAAc,UAAU,YAAY,SAAU,cAAuB;CACnE,OAAO,KAAK,QAAQ,eAAe,YAAY;AACjD;;;;AAKA,cAAc,UAAU,cAAc,SAAU,OAAe,OAAY,cAAuB;CAChG,OAAO,KAAK,QAAQ,iBAAiB,cAAc;EACjD;EACA;EACA,OAAO;CACT,CAAC;AACH;;;;AAKA,cAAc,UAAU,qBAAqB,SAC3C,OACA,OACA,cACA;CACA,OAAO,KAAK,QAAQ,iBAAiB,cAAc;EACjD;EACA;EACA,OAAO;CACT,CAAC;AACH;;;;AAKA,cAAc,UAAU,iBAAiB,SACvC,OACA,OACA,cACA;CACA,OAAO,KAAK,QAAQ,oBAAoB,cAAc;EACpD;EACA;EACA,OAAO;CACT,CAAC;AACH;;;;AAKA,cAAc,UAAU,wBAAwB,SAC9C,OACA,OACA,cACA;CACA,OAAO,KAAK,QAAQ,oBAAoB,cAAc;EACpD;EACA;EACA,OAAO;CACT,CAAC;AACH;;;;AAKA,cAAc,UAAU,mBAAmB,SAAU,OAAe,cAAuB;CACzF,OAAO,KAAK,QAAQ,sBAAsB,cAAc;EACtD;EACA,OAAO;CACT,CAAC;AACH;;;;AAKA,cAAc,UAAU,0BAA0B,SAAU,OAAe,cAAuB;CAChG,OAAO,KAAK,QAAQ,sBAAsB,cAAc;EACtD;EACA,OAAO;CACT,CAAC;AACH;;;;AAKA,cAAc,UAAU,sBAAsB,SAAU,OAAe,cAAuB;CAC5F,OAAO,KAAK,QAAQ,yBAAyB,cAAc;EACzD;EACA,OAAO;CACT,CAAC;AACH;;;;AAKA,cAAc,UAAU,6BAA6B,SACnD,OACA,cACA;CACA,OAAO,KAAK,QAAQ,yBAAyB,cAAc;EACzD;EACA,OAAO;CACT,CAAC;AACH;;;;AAKA,cAAc,UAAU,gBAAgB,SACtC,OACA,QACA,cACA;CACA,OAAO,KAAK,QAAQ,mBAAmB,cAAc;EACnD;EACA;EACA,OAAO;CACT,CAAC;AACH;;;;AAKA,cAAc,UAAU,uBAAuB,SAC7C,OACA,QACA,cACA;CACA,OAAO,KAAK,QAAQ,mBAAmB,cAAc;EACnD;EACA;EACA,OAAO;CACT,CAAC;AACH;;;;AAKA,cAAc,UAAU,mBAAmB,SACzC,OACA,QACA,cACA;CACA,OAAO,KAAK,QAAQ,sBAAsB,cAAc;EACtD;EACA;EACA,OAAO;CACT,CAAC;AACH;;;;AAKA,cAAc,UAAU,0BAA0B,SAChD,OACA,QACA,cACA;CACA,OAAO,KAAK,QAAQ,sBAAsB,cAAc;EACtD;EACA;EACA,OAAO;CACT,CAAC;AACH"}
+{"version":3,"file":"forbidden-methods.mjs","names":[],"sources":["../../../../../../../../../packages/seal/src/validators/methods/forbidden-methods.ts"],"sourcesContent":["import {\n  forbiddenIfEmptyRule,\n  forbiddenIfInRule,\n  forbiddenIfNotEmptyRule,\n  forbiddenIfNotInRule,\n  forbiddenIfNotRule,\n  forbiddenIfRule,\n} from \"../../rules/conditional/forbidden-if-rules\";\nimport { forbiddenRule } from \"../../rules/core/forbidden\";\nimport { BaseValidator } from \"../base-validator\";\n\n/**\n * Marker re-exported by the validators barrel so the dts bundler keeps this\n * module (and its `declare module` augmentation) in the bundled `.d.ts`.\n */\nexport const forbiddenMethodsApplied = true;\n\ndeclare module \"../base-validator\" {\n  interface BaseValidator {\n    /**\n     * Value is forbidden to be present\n     */\n    forbidden(errorMessage?: string): this;\n\n    /**\n     * Value is forbidden if another field equals a specific value (global scope)\n     */\n    forbiddenIf(field: string, value: any, errorMessage?: string): this;\n\n    /**\n     * Value is forbidden if another field equals a specific value (sibling scope)\n     */\n    forbiddenIfSibling(field: string, value: any, errorMessage?: string): this;\n\n    /**\n     * Value is forbidden if another field does NOT equal a specific value (global scope)\n     */\n    forbiddenIfNot(field: string, value: any, errorMessage?: string): this;\n\n    /**\n     * Value is forbidden if another field does NOT equal a specific value (sibling scope)\n     */\n    forbiddenIfNotSibling(field: string, value: any, errorMessage?: string): this;\n\n    /**\n     * Value is forbidden if another field is empty (global scope)\n     */\n    forbiddenIfEmpty(field: string, errorMessage?: string): this;\n\n    /**\n     * Value is forbidden if another field is empty (sibling scope)\n     */\n    forbiddenIfEmptySibling(field: string, errorMessage?: string): this;\n\n    /**\n     * Value is forbidden if another field is not empty (global scope)\n     */\n    forbiddenIfNotEmpty(field: string, errorMessage?: string): this;\n\n    /**\n     * Value is forbidden if another field is not empty (sibling scope)\n     */\n    forbiddenIfNotEmptySibling(field: string, errorMessage?: string): this;\n\n    /**\n     * Value is forbidden if another field's value is in the given array (global scope)\n     */\n    forbiddenIfIn(field: string, values: any[], errorMessage?: string): this;\n\n    /**\n     * Value is forbidden if another field's value is in the given array (sibling scope)\n     */\n    forbiddenIfInSibling(field: string, values: any[], errorMessage?: string): this;\n\n    /**\n     * Value is forbidden if another field's value is NOT in the given array (global scope)\n     */\n    forbiddenIfNotIn(field: string, values: any[], errorMessage?: string): this;\n\n    /**\n     * Value is forbidden if another field's value is NOT in the given array (sibling scope)\n     */\n    forbiddenIfNotInSibling(field: string, values: any[], errorMessage?: string): this;\n  }\n}\n\n/**\n * Value is forbidden to be present\n */\nBaseValidator.prototype.forbidden = function (errorMessage?: string) {\n  return this.addRule(forbiddenRule, errorMessage);\n};\n\n/**\n * Value is forbidden if another field equals a specific value (global scope)\n */\nBaseValidator.prototype.forbiddenIf = function (field: string, value: any, errorMessage?: string) {\n  return this.addRule(forbiddenIfRule, errorMessage, {\n    field,\n    value,\n    scope: \"global\",\n  });\n};\n\n/**\n * Value is forbidden if another field equals a specific value (sibling scope)\n */\nBaseValidator.prototype.forbiddenIfSibling = function (\n  field: string,\n  value: any,\n  errorMessage?: string,\n) {\n  return this.addRule(forbiddenIfRule, errorMessage, {\n    field,\n    value,\n    scope: \"sibling\",\n  });\n};\n\n/**\n * Value is forbidden if another field does NOT equal a specific value (global scope)\n */\nBaseValidator.prototype.forbiddenIfNot = function (\n  field: string,\n  value: any,\n  errorMessage?: string,\n) {\n  return this.addRule(forbiddenIfNotRule, errorMessage, {\n    field,\n    value,\n    scope: \"global\",\n  });\n};\n\n/**\n * Value is forbidden if another field does NOT equal a specific value (sibling scope)\n */\nBaseValidator.prototype.forbiddenIfNotSibling = function (\n  field: string,\n  value: any,\n  errorMessage?: string,\n) {\n  return this.addRule(forbiddenIfNotRule, errorMessage, {\n    field,\n    value,\n    scope: \"sibling\",\n  });\n};\n\n/**\n * Value is forbidden if another field is empty (global scope)\n */\nBaseValidator.prototype.forbiddenIfEmpty = function (field: string, errorMessage?: string) {\n  return this.addRule(forbiddenIfEmptyRule, errorMessage, {\n    field,\n    scope: \"global\",\n  });\n};\n\n/**\n * Value is forbidden if another field is empty (sibling scope)\n */\nBaseValidator.prototype.forbiddenIfEmptySibling = function (field: string, errorMessage?: string) {\n  return this.addRule(forbiddenIfEmptyRule, errorMessage, {\n    field,\n    scope: \"sibling\",\n  });\n};\n\n/**\n * Value is forbidden if another field is not empty (global scope)\n */\nBaseValidator.prototype.forbiddenIfNotEmpty = function (field: string, errorMessage?: string) {\n  return this.addRule(forbiddenIfNotEmptyRule, errorMessage, {\n    field,\n    scope: \"global\",\n  });\n};\n\n/**\n * Value is forbidden if another field is not empty (sibling scope)\n */\nBaseValidator.prototype.forbiddenIfNotEmptySibling = function (\n  field: string,\n  errorMessage?: string,\n) {\n  return this.addRule(forbiddenIfNotEmptyRule, errorMessage, {\n    field,\n    scope: \"sibling\",\n  });\n};\n\n/**\n * Value is forbidden if another field's value is in the given array (global scope)\n */\nBaseValidator.prototype.forbiddenIfIn = function (\n  field: string,\n  values: any[],\n  errorMessage?: string,\n) {\n  return this.addRule(forbiddenIfInRule, errorMessage, {\n    field,\n    values,\n    scope: \"global\",\n  });\n};\n\n/**\n * Value is forbidden if another field's value is in the given array (sibling scope)\n */\nBaseValidator.prototype.forbiddenIfInSibling = function (\n  field: string,\n  values: any[],\n  errorMessage?: string,\n) {\n  return this.addRule(forbiddenIfInRule, errorMessage, {\n    field,\n    values,\n    scope: \"sibling\",\n  });\n};\n\n/**\n * Value is forbidden if another field's value is NOT in the given array (global scope)\n */\nBaseValidator.prototype.forbiddenIfNotIn = function (\n  field: string,\n  values: any[],\n  errorMessage?: string,\n) {\n  return this.addRule(forbiddenIfNotInRule, errorMessage, {\n    field,\n    values,\n    scope: \"global\",\n  });\n};\n\n/**\n * Value is forbidden if another field's value is NOT in the given array (sibling scope)\n */\nBaseValidator.prototype.forbiddenIfNotInSibling = function (\n  field: string,\n  values: any[],\n  errorMessage?: string,\n) {\n  return this.addRule(forbiddenIfNotInRule, errorMessage, {\n    field,\n    values,\n    scope: \"sibling\",\n  });\n};\n"],"mappings":";;;;;;;;;AAeA,MAAa,0BAA0B;;;;AA0EvC,cAAc,UAAU,YAAY,SAAU,cAAuB;CACnE,OAAO,KAAK,QAAQ,eAAe,YAAY;AACjD;;;;AAKA,cAAc,UAAU,cAAc,SAAU,OAAe,OAAY,cAAuB;CAChG,OAAO,KAAK,QAAQ,iBAAiB,cAAc;EACjD;EACA;EACA,OAAO;CACT,CAAC;AACH;;;;AAKA,cAAc,UAAU,qBAAqB,SAC3C,OACA,OACA,cACA;CACA,OAAO,KAAK,QAAQ,iBAAiB,cAAc;EACjD;EACA;EACA,OAAO;CACT,CAAC;AACH;;;;AAKA,cAAc,UAAU,iBAAiB,SACvC,OACA,OACA,cACA;CACA,OAAO,KAAK,QAAQ,oBAAoB,cAAc;EACpD;EACA;EACA,OAAO;CACT,CAAC;AACH;;;;AAKA,cAAc,UAAU,wBAAwB,SAC9C,OACA,OACA,cACA;CACA,OAAO,KAAK,QAAQ,oBAAoB,cAAc;EACpD;EACA;EACA,OAAO;CACT,CAAC;AACH;;;;AAKA,cAAc,UAAU,mBAAmB,SAAU,OAAe,cAAuB;CACzF,OAAO,KAAK,QAAQ,sBAAsB,cAAc;EACtD;EACA,OAAO;CACT,CAAC;AACH;;;;AAKA,cAAc,UAAU,0BAA0B,SAAU,OAAe,cAAuB;CAChG,OAAO,KAAK,QAAQ,sBAAsB,cAAc;EACtD;EACA,OAAO;CACT,CAAC;AACH;;;;AAKA,cAAc,UAAU,sBAAsB,SAAU,OAAe,cAAuB;CAC5F,OAAO,KAAK,QAAQ,yBAAyB,cAAc;EACzD;EACA,OAAO;CACT,CAAC;AACH;;;;AAKA,cAAc,UAAU,6BAA6B,SACnD,OACA,cACA;CACA,OAAO,KAAK,QAAQ,yBAAyB,cAAc;EACzD;EACA,OAAO;CACT,CAAC;AACH;;;;AAKA,cAAc,UAAU,gBAAgB,SACtC,OACA,QACA,cACA;CACA,OAAO,KAAK,QAAQ,mBAAmB,cAAc;EACnD;EACA;EACA,OAAO;CACT,CAAC;AACH;;;;AAKA,cAAc,UAAU,uBAAuB,SAC7C,OACA,QACA,cACA;CACA,OAAO,KAAK,QAAQ,mBAAmB,cAAc;EACnD;EACA;EACA,OAAO;CACT,CAAC;AACH;;;;AAKA,cAAc,UAAU,mBAAmB,SACzC,OACA,QACA,cACA;CACA,OAAO,KAAK,QAAQ,sBAAsB,cAAc;EACtD;EACA;EACA,OAAO;CACT,CAAC;AACH;;;;AAKA,cAAc,UAAU,0BAA0B,SAChD,OACA,QACA,cACA;CACA,OAAO,KAAK,QAAQ,sBAAsB,cAAc;EACtD;EACA;EACA,OAAO;CACT,CAAC;AACH"}

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

@@ -1,4 +1,4 @@
-//#region ../seal/src/validators/methods/present-methods.d.ts
+//#region ../../packages/seal/src/validators/methods/present-methods.d.ts
 /**
  * Marker re-exported by the validators barrel so the dts bundler keeps this
  * module (and its `declare module` augmentation) in the bundled `.d.ts`.

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

@@ -1 +1 @@
-{"version":3,"file":"present-methods.d.mts","names":[],"sources":["../../../../../../../../seal/src/validators/methods/present-methods.ts"],"mappings":";;AAwBA;;;cAAa,qBAAA;AAAA;EAAA,UAGD,aAAA;IAH8B;;;IAOtC,WAAA,CAAY,KAAA,UAAe,YAAA;IAA3B;;;IAKA,kBAAA,CAAmB,KAAA,UAAe,YAAA;IAAf;;;IAKnB,cAAA,CAAe,KAAA,UAAe,YAAA;IAAA;;;IAK9B,qBAAA,CAAsB,KAAA,UAAe,YAAA;IAKrC;;;IAAA,SAAA,CAAU,KAAA,UAAe,KAAA,OAAY,YAAA;IAKrC;;;IAAA,gBAAA,CAAiB,KAAA,UAAe,KAAA,OAAY,YAAA;IAK5C;;;IAAA,aAAA,CAAc,KAAA,UAAe,KAAA,OAAY,YAAA;IAKzC;;;IAAA,oBAAA,CAAqB,KAAA,UAAe,KAAA,OAAY,YAAA;IAKhD;;;IAAA,cAAA,CAAe,KAAA,UAAe,YAAA;IAKR;;;IAAtB,qBAAA,CAAsB,KAAA,UAAe,YAAA;IAKJ;;;IAAjC,iBAAA,CAAkB,KAAA,UAAe,YAAA;IAUjC;;;IALA,wBAAA,CAAyB,KAAA,UAAe,YAAA;IAUxC;;;IALA,WAAA,CAAY,KAAA,UAAe,MAAA,SAAe,YAAA;IAU1C;;;IALA,kBAAA,CAAmB,KAAA,UAAe,MAAA,SAAe,YAAA;IAUjD;;;IALA,cAAA,CAAe,KAAA,UAAe,MAAA,SAAe,YAAA;IAU7C;;;IALA,qBAAA,CAAsB,KAAA,UAAe,MAAA,SAAe,YAAA;IAU7B;;;IALvB,cAAA,CAAe,MAAA,YAAkB,YAAA;IAUG;;;IALpC,sBAAA,CAAuB,MAAA,YAAkB,YAAA;IAezC;;;IAVA,iBAAA,CAAkB,MAAA,YAAkB,YAAA;IAeb;;;IAVvB,yBAAA,CAA0B,MAAA,YAAkB,YAAA;IAeR;;;IAVpC,cAAA,CAAe,MAAA,YAAkB,YAAA;IAegC;;AAAA;IAVjE,sBAAA,CAAuB,MAAA,YAAkB,YAAA;;;;IAKzC,iBAAA,CAAkB,MAAA,YAAkB,YAAA;;;;IAKpC,yBAAA,CAA0B,MAAA,YAAkB,YAAA;EAAA;AAAA"}
+{"version":3,"file":"present-methods.d.mts","names":[],"sources":["../../../../../../../../../packages/seal/src/validators/methods/present-methods.ts"],"mappings":";;AAwBA;;;cAAa,qBAAA;AAAA;EAAA,UAGD,aAAA;IAH8B;;;IAOtC,WAAA,CAAY,KAAA,UAAe,YAAA;IAA3B;;;IAKA,kBAAA,CAAmB,KAAA,UAAe,YAAA;IAAf;;;IAKnB,cAAA,CAAe,KAAA,UAAe,YAAA;IAAA;;;IAK9B,qBAAA,CAAsB,KAAA,UAAe,YAAA;IAKrC;;;IAAA,SAAA,CAAU,KAAA,UAAe,KAAA,OAAY,YAAA;IAKrC;;;IAAA,gBAAA,CAAiB,KAAA,UAAe,KAAA,OAAY,YAAA;IAK5C;;;IAAA,aAAA,CAAc,KAAA,UAAe,KAAA,OAAY,YAAA;IAKzC;;;IAAA,oBAAA,CAAqB,KAAA,UAAe,KAAA,OAAY,YAAA;IAKhD;;;IAAA,cAAA,CAAe,KAAA,UAAe,YAAA;IAKR;;;IAAtB,qBAAA,CAAsB,KAAA,UAAe,YAAA;IAKJ;;;IAAjC,iBAAA,CAAkB,KAAA,UAAe,YAAA;IAUjC;;;IALA,wBAAA,CAAyB,KAAA,UAAe,YAAA;IAUxC;;;IALA,WAAA,CAAY,KAAA,UAAe,MAAA,SAAe,YAAA;IAU1C;;;IALA,kBAAA,CAAmB,KAAA,UAAe,MAAA,SAAe,YAAA;IAUjD;;;IALA,cAAA,CAAe,KAAA,UAAe,MAAA,SAAe,YAAA;IAU7C;;;IALA,qBAAA,CAAsB,KAAA,UAAe,MAAA,SAAe,YAAA;IAU7B;;;IALvB,cAAA,CAAe,MAAA,YAAkB,YAAA;IAUG;;;IALpC,sBAAA,CAAuB,MAAA,YAAkB,YAAA;IAezC;;;IAVA,iBAAA,CAAkB,MAAA,YAAkB,YAAA;IAeb;;;IAVvB,yBAAA,CAA0B,MAAA,YAAkB,YAAA;IAeR;;;IAVpC,cAAA,CAAe,MAAA,YAAkB,YAAA;IAegC;;AAAA;IAVjE,sBAAA,CAAuB,MAAA,YAAkB,YAAA;;;;IAKzC,iBAAA,CAAkB,MAAA,YAAkB,YAAA;;;;IAKpC,yBAAA,CAA0B,MAAA,YAAkB,YAAA;EAAA;AAAA"}

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

@@ -4,7 +4,7 @@ import { presentUnlessRule } from "../../rules/conditional/present-unless-rules.
 import { presentWithAllRule, presentWithAnyRule, presentWithRule } from "../../rules/conditional/present-with-rules.mjs";
 import { presentWithoutAllRule, presentWithoutAnyRule, presentWithoutRule } from "../../rules/conditional/present-without-rules.mjs";
 
-//#region ../seal/src/validators/methods/present-methods.ts
+//#region ../../packages/seal/src/validators/methods/present-methods.ts
 /**
 * Marker re-exported by the validators barrel so the dts bundler keeps this
 * module (and its `declare module` augmentation) in the bundled `.d.ts`.

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

@@ -1 +1 @@
-{"version":3,"file":"present-methods.mjs","names":[],"sources":["../../../../../../../../seal/src/validators/methods/present-methods.ts"],"sourcesContent":["import {\n  presentIfEmptyRule,\n  presentIfInRule,\n  presentIfNotEmptyRule,\n  presentIfNotInRule,\n  presentIfRule,\n} from \"../../rules/conditional/present-if-rules\";\nimport { presentUnlessRule } from \"../../rules/conditional/present-unless-rules\";\nimport {\n  presentWithAllRule,\n  presentWithAnyRule,\n  presentWithRule,\n} from \"../../rules/conditional/present-with-rules\";\nimport {\n  presentWithoutAllRule,\n  presentWithoutAnyRule,\n  presentWithoutRule,\n} from \"../../rules/conditional/present-without-rules\";\nimport { BaseValidator } from \"../base-validator\";\n\n/**\n * Marker re-exported by the validators barrel so the dts bundler keeps this\n * module (and its `declare module` augmentation) in the bundled `.d.ts`.\n */\nexport const presentMethodsApplied = true;\n\ndeclare module \"../base-validator\" {\n  interface BaseValidator {\n    /**\n     * Field must be present if another field exists\n     */\n    presentWith(field: string, errorMessage?: string): this;\n\n    /**\n     * Field must be present if another sibling field exists\n     */\n    presentWithSibling(field: string, errorMessage?: string): this;\n\n    /**\n     * Field must be present if another field is missing\n     */\n    presentWithout(field: string, errorMessage?: string): this;\n\n    /**\n     * Field must be present if another sibling field is missing\n     */\n    presentWithoutSibling(field: string, errorMessage?: string): this;\n\n    /**\n     * Field must be present if another field equals a specific value\n     */\n    presentIf(field: string, value: any, errorMessage?: string): this;\n\n    /**\n     * Field must be present if another sibling field equals a specific value\n     */\n    presentIfSibling(field: string, value: any, errorMessage?: string): this;\n\n    /**\n     * Field must be present unless another field equals a specific value\n     */\n    presentUnless(field: string, value: any, errorMessage?: string): this;\n\n    /**\n     * Field must be present unless another sibling field equals a specific value\n     */\n    presentUnlessSibling(field: string, value: any, errorMessage?: string): this;\n\n    /**\n     * Field must be present if another field is empty\n     */\n    presentIfEmpty(field: string, errorMessage?: string): this;\n\n    /**\n     * Field must be present if another sibling field is empty\n     */\n    presentIfEmptySibling(field: string, errorMessage?: string): this;\n\n    /**\n     * Field must be present if another field is not empty\n     */\n    presentIfNotEmpty(field: string, errorMessage?: string): this;\n\n    /**\n     * Field must be present if another sibling field is not empty\n     */\n    presentIfNotEmptySibling(field: string, errorMessage?: string): this;\n\n    /**\n     * Field must be present if another field's value is in the given array\n     */\n    presentIfIn(field: string, values: any[], errorMessage?: string): this;\n\n    /**\n     * Field must be present if another sibling field's value is in the given array\n     */\n    presentIfInSibling(field: string, values: any[], errorMessage?: string): this;\n\n    /**\n     * Field must be present if another field's value is NOT in the given array\n     */\n    presentIfNotIn(field: string, values: any[], errorMessage?: string): this;\n\n    /**\n     * Field must be present if another sibling field's value is NOT in the given array\n     */\n    presentIfNotInSibling(field: string, values: any[], errorMessage?: string): this;\n\n    /**\n     * Field must be present if all specified fields exist\n     */\n    presentWithAll(fields: string[], errorMessage?: string): this;\n\n    /**\n     * Field must be present if all specified sibling fields exist\n     */\n    presentWithAllSiblings(fields: string[], errorMessage?: string): this;\n\n    /**\n     * Field must be present if all specified fields are missing\n     */\n    presentWithoutAll(fields: string[], errorMessage?: string): this;\n\n    /**\n     * Field must be present if all specified sibling fields are missing\n     */\n    presentWithoutAllSiblings(fields: string[], errorMessage?: string): this;\n\n    /**\n     * Field must be present if any of the specified fields exists\n     */\n    presentWithAny(fields: string[], errorMessage?: string): this;\n\n    /**\n     * Field must be present if any of the specified sibling fields exists\n     */\n    presentWithAnySiblings(fields: string[], errorMessage?: string): this;\n\n    /**\n     * Field must be present if any of the specified fields is missing\n     */\n    presentWithoutAny(fields: string[], errorMessage?: string): this;\n\n    /**\n     * Field must be present if any of the specified sibling fields is missing\n     */\n    presentWithoutAnySiblings(fields: string[], errorMessage?: string): this;\n  }\n}\n\n// ==================== PRESENT: BASED ON FIELD PRESENCE ====================\n\n/**\n * Field must be present if another field exists\n */\nBaseValidator.prototype.presentWith = function (field: string, errorMessage?: string) {\n  return this.addRule(presentWithRule, errorMessage, {\n    field,\n    scope: \"global\",\n  });\n};\n\n/**\n * Field must be present if another sibling field exists\n */\nBaseValidator.prototype.presentWithSibling = function (field: string, errorMessage?: string) {\n  return this.addRule(presentWithRule, errorMessage, {\n    field,\n    scope: \"sibling\",\n  });\n};\n\n/**\n * Field must be present if another field is missing\n */\nBaseValidator.prototype.presentWithout = function (field: string, errorMessage?: string) {\n  return this.addRule(presentWithoutRule, errorMessage, {\n    field,\n    scope: \"global\",\n  });\n};\n\n/**\n * Field must be present if another sibling field is missing\n */\nBaseValidator.prototype.presentWithoutSibling = function (field: string, errorMessage?: string) {\n  return this.addRule(presentWithoutRule, errorMessage, {\n    field,\n    scope: \"sibling\",\n  });\n};\n\n// ==================== PRESENT: BASED ON FIELD VALUE ====================\n\n/**\n * Field must be present if another field equals a specific value\n */\nBaseValidator.prototype.presentIf = function (field: string, value: any, errorMessage?: string) {\n  return this.addRule(presentIfRule, errorMessage, {\n    field,\n    value,\n    scope: \"global\",\n  });\n};\n\n/**\n * Field must be present if another sibling field equals a specific value\n */\nBaseValidator.prototype.presentIfSibling = function (\n  field: string,\n  value: any,\n  errorMessage?: string,\n) {\n  return this.addRule(presentIfRule, errorMessage, {\n    field,\n    value,\n    scope: \"sibling\",\n  });\n};\n\n/**\n * Field must be present unless another field equals a specific value\n */\nBaseValidator.prototype.presentUnless = function (\n  field: string,\n  value: any,\n  errorMessage?: string,\n) {\n  return this.addRule(presentUnlessRule, errorMessage, {\n    field,\n    value,\n    scope: \"global\",\n  });\n};\n\n/**\n * Field must be present unless another sibling field equals a specific value\n */\nBaseValidator.prototype.presentUnlessSibling = function (\n  field: string,\n  value: any,\n  errorMessage?: string,\n) {\n  return this.addRule(presentUnlessRule, errorMessage, {\n    field,\n    value,\n    scope: \"sibling\",\n  });\n};\n\n// ==================== PRESENT: BASED ON FIELD EMPTY STATE ====================\n\n/**\n * Field must be present if another field is empty\n */\nBaseValidator.prototype.presentIfEmpty = function (field: string, errorMessage?: string) {\n  return this.addRule(presentIfEmptyRule, errorMessage, {\n    field,\n    scope: \"global\",\n  });\n};\n\n/**\n * Field must be present if another sibling field is empty\n */\nBaseValidator.prototype.presentIfEmptySibling = function (field: string, errorMessage?: string) {\n  return this.addRule(presentIfEmptyRule, errorMessage, {\n    field,\n    scope: \"sibling\",\n  });\n};\n\n/**\n * Field must be present if another field is not empty\n */\nBaseValidator.prototype.presentIfNotEmpty = function (field: string, errorMessage?: string) {\n  return this.addRule(presentIfNotEmptyRule, errorMessage, {\n    field,\n    scope: \"global\",\n  });\n};\n\n/**\n * Field must be present if another sibling field is not empty\n */\nBaseValidator.prototype.presentIfNotEmptySibling = function (field: string, errorMessage?: string) {\n  return this.addRule(presentIfNotEmptyRule, errorMessage, {\n    field,\n    scope: \"sibling\",\n  });\n};\n\n/**\n * Field must be present if another field's value is in the given array\n */\nBaseValidator.prototype.presentIfIn = function (\n  field: string,\n  values: any[],\n  errorMessage?: string,\n) {\n  return this.addRule(presentIfInRule, errorMessage, {\n    field,\n    values,\n    scope: \"global\",\n  });\n};\n\n/**\n * Field must be present if another sibling field's value is in the given array\n */\nBaseValidator.prototype.presentIfInSibling = function (\n  field: string,\n  values: any[],\n  errorMessage?: string,\n) {\n  return this.addRule(presentIfInRule, errorMessage, {\n    field,\n    values,\n    scope: \"sibling\",\n  });\n};\n\n/**\n * Field must be present if another field's value is NOT in the given array\n */\nBaseValidator.prototype.presentIfNotIn = function (\n  field: string,\n  values: any[],\n  errorMessage?: string,\n) {\n  return this.addRule(presentIfNotInRule, errorMessage, {\n    field,\n    values,\n    scope: \"global\",\n  });\n};\n\n/**\n * Field must be present if another sibling field's value is NOT in the given array\n */\nBaseValidator.prototype.presentIfNotInSibling = function (\n  field: string,\n  values: any[],\n  errorMessage?: string,\n) {\n  return this.addRule(presentIfNotInRule, errorMessage, {\n    field,\n    values,\n    scope: \"sibling\",\n  });\n};\n\n// ==================== PRESENT: BASED ON MULTIPLE FIELDS (ALL) ====================\n\n/**\n * Field must be present if all specified fields exist\n */\nBaseValidator.prototype.presentWithAll = function (fields: string[], errorMessage?: string) {\n  return this.addRule(presentWithAllRule, errorMessage, {\n    fields,\n    scope: \"global\",\n  });\n};\n\n/**\n * Field must be present if all specified sibling fields exist\n */\nBaseValidator.prototype.presentWithAllSiblings = function (\n  fields: string[],\n  errorMessage?: string,\n) {\n  return this.addRule(presentWithAllRule, errorMessage, {\n    fields,\n    scope: \"sibling\",\n  });\n};\n\n/**\n * Field must be present if all specified fields are missing\n */\nBaseValidator.prototype.presentWithoutAll = function (fields: string[], errorMessage?: string) {\n  return this.addRule(presentWithoutAllRule, errorMessage, {\n    fields,\n    scope: \"global\",\n  });\n};\n\n/**\n * Field must be present if all specified sibling fields are missing\n */\nBaseValidator.prototype.presentWithoutAllSiblings = function (\n  fields: string[],\n  errorMessage?: string,\n) {\n  return this.addRule(presentWithoutAllRule, errorMessage, {\n    fields,\n    scope: \"sibling\",\n  });\n};\n\n// ==================== PRESENT: BASED ON MULTIPLE FIELDS (ANY) ====================\n\n/**\n * Field must be present if any of the specified fields exists\n */\nBaseValidator.prototype.presentWithAny = function (fields: string[], errorMessage?: string) {\n  return this.addRule(presentWithAnyRule, errorMessage, {\n    fields,\n    scope: \"global\",\n  });\n};\n\n/**\n * Field must be present if any of the specified sibling fields exists\n */\nBaseValidator.prototype.presentWithAnySiblings = function (\n  fields: string[],\n  errorMessage?: string,\n) {\n  return this.addRule(presentWithAnyRule, errorMessage, {\n    fields,\n    scope: \"sibling\",\n  });\n};\n\n/**\n * Field must be present if any of the specified fields is missing\n */\nBaseValidator.prototype.presentWithoutAny = function (fields: string[], errorMessage?: string) {\n  return this.addRule(presentWithoutAnyRule, errorMessage, {\n    fields,\n    scope: \"global\",\n  });\n};\n\n/**\n * Field must be present if any of the specified sibling fields is missing\n */\nBaseValidator.prototype.presentWithoutAnySiblings = function (\n  fields: string[],\n  errorMessage?: string,\n) {\n  return this.addRule(presentWithoutAnyRule, errorMessage, {\n    fields,\n    scope: \"sibling\",\n  });\n};\n"],"mappings":"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"}
+{"version":3,"file":"present-methods.mjs","names":[],"sources":["../../../../../../../../../packages/seal/src/validators/methods/present-methods.ts"],"sourcesContent":["import {\n  presentIfEmptyRule,\n  presentIfInRule,\n  presentIfNotEmptyRule,\n  presentIfNotInRule,\n  presentIfRule,\n} from \"../../rules/conditional/present-if-rules\";\nimport { presentUnlessRule } from \"../../rules/conditional/present-unless-rules\";\nimport {\n  presentWithAllRule,\n  presentWithAnyRule,\n  presentWithRule,\n} from \"../../rules/conditional/present-with-rules\";\nimport {\n  presentWithoutAllRule,\n  presentWithoutAnyRule,\n  presentWithoutRule,\n} from \"../../rules/conditional/present-without-rules\";\nimport { BaseValidator } from \"../base-validator\";\n\n/**\n * Marker re-exported by the validators barrel so the dts bundler keeps this\n * module (and its `declare module` augmentation) in the bundled `.d.ts`.\n */\nexport const presentMethodsApplied = true;\n\ndeclare module \"../base-validator\" {\n  interface BaseValidator {\n    /**\n     * Field must be present if another field exists\n     */\n    presentWith(field: string, errorMessage?: string): this;\n\n    /**\n     * Field must be present if another sibling field exists\n     */\n    presentWithSibling(field: string, errorMessage?: string): this;\n\n    /**\n     * Field must be present if another field is missing\n     */\n    presentWithout(field: string, errorMessage?: string): this;\n\n    /**\n     * Field must be present if another sibling field is missing\n     */\n    presentWithoutSibling(field: string, errorMessage?: string): this;\n\n    /**\n     * Field must be present if another field equals a specific value\n     */\n    presentIf(field: string, value: any, errorMessage?: string): this;\n\n    /**\n     * Field must be present if another sibling field equals a specific value\n     */\n    presentIfSibling(field: string, value: any, errorMessage?: string): this;\n\n    /**\n     * Field must be present unless another field equals a specific value\n     */\n    presentUnless(field: string, value: any, errorMessage?: string): this;\n\n    /**\n     * Field must be present unless another sibling field equals a specific value\n     */\n    presentUnlessSibling(field: string, value: any, errorMessage?: string): this;\n\n    /**\n     * Field must be present if another field is empty\n     */\n    presentIfEmpty(field: string, errorMessage?: string): this;\n\n    /**\n     * Field must be present if another sibling field is empty\n     */\n    presentIfEmptySibling(field: string, errorMessage?: string): this;\n\n    /**\n     * Field must be present if another field is not empty\n     */\n    presentIfNotEmpty(field: string, errorMessage?: string): this;\n\n    /**\n     * Field must be present if another sibling field is not empty\n     */\n    presentIfNotEmptySibling(field: string, errorMessage?: string): this;\n\n    /**\n     * Field must be present if another field's value is in the given array\n     */\n    presentIfIn(field: string, values: any[], errorMessage?: string): this;\n\n    /**\n     * Field must be present if another sibling field's value is in the given array\n     */\n    presentIfInSibling(field: string, values: any[], errorMessage?: string): this;\n\n    /**\n     * Field must be present if another field's value is NOT in the given array\n     */\n    presentIfNotIn(field: string, values: any[], errorMessage?: string): this;\n\n    /**\n     * Field must be present if another sibling field's value is NOT in the given array\n     */\n    presentIfNotInSibling(field: string, values: any[], errorMessage?: string): this;\n\n    /**\n     * Field must be present if all specified fields exist\n     */\n    presentWithAll(fields: string[], errorMessage?: string): this;\n\n    /**\n     * Field must be present if all specified sibling fields exist\n     */\n    presentWithAllSiblings(fields: string[], errorMessage?: string): this;\n\n    /**\n     * Field must be present if all specified fields are missing\n     */\n    presentWithoutAll(fields: string[], errorMessage?: string): this;\n\n    /**\n     * Field must be present if all specified sibling fields are missing\n     */\n    presentWithoutAllSiblings(fields: string[], errorMessage?: string): this;\n\n    /**\n     * Field must be present if any of the specified fields exists\n     */\n    presentWithAny(fields: string[], errorMessage?: string): this;\n\n    /**\n     * Field must be present if any of the specified sibling fields exists\n     */\n    presentWithAnySiblings(fields: string[], errorMessage?: string): this;\n\n    /**\n     * Field must be present if any of the specified fields is missing\n     */\n    presentWithoutAny(fields: string[], errorMessage?: string): this;\n\n    /**\n     * Field must be present if any of the specified sibling fields is missing\n     */\n    presentWithoutAnySiblings(fields: string[], errorMessage?: string): this;\n  }\n}\n\n// ==================== PRESENT: BASED ON FIELD PRESENCE ====================\n\n/**\n * Field must be present if another field exists\n */\nBaseValidator.prototype.presentWith = function (field: string, errorMessage?: string) {\n  return this.addRule(presentWithRule, errorMessage, {\n    field,\n    scope: \"global\",\n  });\n};\n\n/**\n * Field must be present if another sibling field exists\n */\nBaseValidator.prototype.presentWithSibling = function (field: string, errorMessage?: string) {\n  return this.addRule(presentWithRule, errorMessage, {\n    field,\n    scope: \"sibling\",\n  });\n};\n\n/**\n * Field must be present if another field is missing\n */\nBaseValidator.prototype.presentWithout = function (field: string, errorMessage?: string) {\n  return this.addRule(presentWithoutRule, errorMessage, {\n    field,\n    scope: \"global\",\n  });\n};\n\n/**\n * Field must be present if another sibling field is missing\n */\nBaseValidator.prototype.presentWithoutSibling = function (field: string, errorMessage?: string) {\n  return this.addRule(presentWithoutRule, errorMessage, {\n    field,\n    scope: \"sibling\",\n  });\n};\n\n// ==================== PRESENT: BASED ON FIELD VALUE ====================\n\n/**\n * Field must be present if another field equals a specific value\n */\nBaseValidator.prototype.presentIf = function (field: string, value: any, errorMessage?: string) {\n  return this.addRule(presentIfRule, errorMessage, {\n    field,\n    value,\n    scope: \"global\",\n  });\n};\n\n/**\n * Field must be present if another sibling field equals a specific value\n */\nBaseValidator.prototype.presentIfSibling = function (\n  field: string,\n  value: any,\n  errorMessage?: string,\n) {\n  return this.addRule(presentIfRule, errorMessage, {\n    field,\n    value,\n    scope: \"sibling\",\n  });\n};\n\n/**\n * Field must be present unless another field equals a specific value\n */\nBaseValidator.prototype.presentUnless = function (\n  field: string,\n  value: any,\n  errorMessage?: string,\n) {\n  return this.addRule(presentUnlessRule, errorMessage, {\n    field,\n    value,\n    scope: \"global\",\n  });\n};\n\n/**\n * Field must be present unless another sibling field equals a specific value\n */\nBaseValidator.prototype.presentUnlessSibling = function (\n  field: string,\n  value: any,\n  errorMessage?: string,\n) {\n  return this.addRule(presentUnlessRule, errorMessage, {\n    field,\n    value,\n    scope: \"sibling\",\n  });\n};\n\n// ==================== PRESENT: BASED ON FIELD EMPTY STATE ====================\n\n/**\n * Field must be present if another field is empty\n */\nBaseValidator.prototype.presentIfEmpty = function (field: string, errorMessage?: string) {\n  return this.addRule(presentIfEmptyRule, errorMessage, {\n    field,\n    scope: \"global\",\n  });\n};\n\n/**\n * Field must be present if another sibling field is empty\n */\nBaseValidator.prototype.presentIfEmptySibling = function (field: string, errorMessage?: string) {\n  return this.addRule(presentIfEmptyRule, errorMessage, {\n    field,\n    scope: \"sibling\",\n  });\n};\n\n/**\n * Field must be present if another field is not empty\n */\nBaseValidator.prototype.presentIfNotEmpty = function (field: string, errorMessage?: string) {\n  return this.addRule(presentIfNotEmptyRule, errorMessage, {\n    field,\n    scope: \"global\",\n  });\n};\n\n/**\n * Field must be present if another sibling field is not empty\n */\nBaseValidator.prototype.presentIfNotEmptySibling = function (field: string, errorMessage?: string) {\n  return this.addRule(presentIfNotEmptyRule, errorMessage, {\n    field,\n    scope: \"sibling\",\n  });\n};\n\n/**\n * Field must be present if another field's value is in the given array\n */\nBaseValidator.prototype.presentIfIn = function (\n  field: string,\n  values: any[],\n  errorMessage?: string,\n) {\n  return this.addRule(presentIfInRule, errorMessage, {\n    field,\n    values,\n    scope: \"global\",\n  });\n};\n\n/**\n * Field must be present if another sibling field's value is in the given array\n */\nBaseValidator.prototype.presentIfInSibling = function (\n  field: string,\n  values: any[],\n  errorMessage?: string,\n) {\n  return this.addRule(presentIfInRule, errorMessage, {\n    field,\n    values,\n    scope: \"sibling\",\n  });\n};\n\n/**\n * Field must be present if another field's value is NOT in the given array\n */\nBaseValidator.prototype.presentIfNotIn = function (\n  field: string,\n  values: any[],\n  errorMessage?: string,\n) {\n  return this.addRule(presentIfNotInRule, errorMessage, {\n    field,\n    values,\n    scope: \"global\",\n  });\n};\n\n/**\n * Field must be present if another sibling field's value is NOT in the given array\n */\nBaseValidator.prototype.presentIfNotInSibling = function (\n  field: string,\n  values: any[],\n  errorMessage?: string,\n) {\n  return this.addRule(presentIfNotInRule, errorMessage, {\n    field,\n    values,\n    scope: \"sibling\",\n  });\n};\n\n// ==================== PRESENT: BASED ON MULTIPLE FIELDS (ALL) ====================\n\n/**\n * Field must be present if all specified fields exist\n */\nBaseValidator.prototype.presentWithAll = function (fields: string[], errorMessage?: string) {\n  return this.addRule(presentWithAllRule, errorMessage, {\n    fields,\n    scope: \"global\",\n  });\n};\n\n/**\n * Field must be present if all specified sibling fields exist\n */\nBaseValidator.prototype.presentWithAllSiblings = function (\n  fields: string[],\n  errorMessage?: string,\n) {\n  return this.addRule(presentWithAllRule, errorMessage, {\n    fields,\n    scope: \"sibling\",\n  });\n};\n\n/**\n * Field must be present if all specified fields are missing\n */\nBaseValidator.prototype.presentWithoutAll = function (fields: string[], errorMessage?: string) {\n  return this.addRule(presentWithoutAllRule, errorMessage, {\n    fields,\n    scope: \"global\",\n  });\n};\n\n/**\n * Field must be present if all specified sibling fields are missing\n */\nBaseValidator.prototype.presentWithoutAllSiblings = function (\n  fields: string[],\n  errorMessage?: string,\n) {\n  return this.addRule(presentWithoutAllRule, errorMessage, {\n    fields,\n    scope: \"sibling\",\n  });\n};\n\n// ==================== PRESENT: BASED ON MULTIPLE FIELDS (ANY) ====================\n\n/**\n * Field must be present if any of the specified fields exists\n */\nBaseValidator.prototype.presentWithAny = function (fields: string[], errorMessage?: string) {\n  return this.addRule(presentWithAnyRule, errorMessage, {\n    fields,\n    scope: \"global\",\n  });\n};\n\n/**\n * Field must be present if any of the specified sibling fields exists\n */\nBaseValidator.prototype.presentWithAnySiblings = function (\n  fields: string[],\n  errorMessage?: string,\n) {\n  return this.addRule(presentWithAnyRule, errorMessage, {\n    fields,\n    scope: \"sibling\",\n  });\n};\n\n/**\n * Field must be present if any of the specified fields is missing\n */\nBaseValidator.prototype.presentWithoutAny = function (fields: string[], errorMessage?: string) {\n  return this.addRule(presentWithoutAnyRule, errorMessage, {\n    fields,\n    scope: \"global\",\n  });\n};\n\n/**\n * Field must be present if any of the specified sibling fields is missing\n */\nBaseValidator.prototype.presentWithoutAnySiblings = function (\n  fields: string[],\n  errorMessage?: string,\n) {\n  return this.addRule(presentWithoutAnyRule, errorMessage, {\n    fields,\n    scope: \"sibling\",\n  });\n};\n"],"mappings":"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"}

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

@@ -1,5 +1,6 @@
 import { SchemaContext } from "../../types/context-types.mjs";
-//#region ../seal/src/validators/methods/required-methods.d.ts
+
+//#region ../../packages/seal/src/validators/methods/required-methods.d.ts
 /**
  * Marker re-exported by the validators barrel so the dts bundler keeps this
  * module (and its `declare module` augmentation) in the bundled `.d.ts`.

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

@@ -1 +1 @@
-{"version":3,"file":"required-methods.d.mts","names":[],"sources":["../../../../../../../../seal/src/validators/methods/required-methods.ts"],"mappings":";;;;;AAiCA;;;cAAa,sBAAA;AAAA;EAAA,UAGD,aAAA;IAH+B;;;IAOvC,QAAA,CAAS,YAAA;IAAT;;;IAKA,OAAA,CAAQ,YAAA;IAMR;;;;IAAA,QAAA;MAAqB,UAAA;IAAA;IAoBO;;;;;;;;;;;;;IAL5B,OAAA;MAAoB,UAAA;MAAkB,UAAA;IAAA;IA8BO;;;IAzB7C,YAAA,CAAa,KAAA,UAAe,YAAA;IA8Bc;;;IAzB1C,mBAAA,CAAoB,KAAA,UAAe,YAAA;IA8Bc;;;IAzBjD,eAAA,CAAgB,KAAA,UAAe,YAAA;IAmC/B;;;IA9BA,sBAAA,CAAuB,KAAA,UAAe,YAAA;IAmCnB;;;IA9BnB,UAAA,CAAW,KAAA,UAAe,KAAA,OAAY,YAAA;IAmCG;;;IA9BzC,iBAAA,CAAkB,KAAA,UAAe,KAAA,OAAY,YAAA;IAwC7C;;;IAnCA,cAAA,CAAe,KAAA,UAAe,KAAA,OAAY,YAAA;IAwCvB;;;IAnCnB,qBAAA,CAAsB,KAAA,UAAe,KAAA,OAAY,YAAA;IAwCJ;;;IAnC7C,eAAA,CAAgB,KAAA,UAAe,YAAA;IA6C/B;;;IAxCA,sBAAA,CAAuB,KAAA,UAAe,YAAA;IA6ChB;;;IAxCtB,kBAAA,CAAmB,KAAA,UAAe,YAAA;IA6Cc;;;IAxChD,yBAAA,CAA0B,KAAA,UAAe,YAAA;IA6CE;;;IAxC3C,kBAAA,CAAmB,MAAA,YAAkB,YAAA;IA6Ca;;;IAxClD,0BAAA,CAA2B,MAAA,YAAkB,YAAA;IA6CC;;;IAxC9C,kBAAA,CAAmB,MAAA,YAAkB,YAAA;IA6CgB;;;IAxCrD,0BAAA,CAA2B,MAAA,YAAkB,YAAA;IAkD7C;;;IA7CA,qBAAA,CAAsB,MAAA,YAAkB,YAAA;IAkDrB;;;IA7CnB,6BAAA,CAA8B,MAAA,YAAkB,YAAA;IAkDH;;;IA7C7C,qBAAA,CAAsB,MAAA,YAAkB,YAAA;IAuDxC;;;IAlDA,6BAAA,CAA8B,MAAA,YAAkB,YAAA;IAuD7B;;;IAlDnB,YAAA,CAAa,KAAA,UAAe,MAAA,SAAe,YAAA;IAuDE;;;IAlD7C,mBAAA,CAAoB,KAAA,UAAe,MAAA,SAAe,YAAA;IA6EA;;;IAxElD,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"}
+{"version":3,"file":"required-methods.d.mts","names":[],"sources":["../../../../../../../../../packages/seal/src/validators/methods/required-methods.ts"],"mappings":";;;;;AAiCA;;;;cAAa,sBAAA;AAAA;EAAA,UAGD,aAAA;IAyNc;;;IArNtB,QAAA,CAAS,YAAA;IAAA;;;IAKT,OAAA,CAAQ,YAAA;IAMa;;;;IAArB,QAAA;MAAqB,UAAA;IAAA;IAyBrB;;;;;;;;;;;;;IAVA,OAAA;MAAoB,UAAA;MAAkB,UAAA;IAAA;IAmCtC;;;IA9BA,YAAA,CAAa,KAAA,UAAe,YAAA;IAmC5B;;;IA9BA,mBAAA,CAAoB,KAAA,UAAe,YAAA;IAmCnC;;;IA9BA,eAAA,CAAgB,KAAA,UAAe,YAAA;IAmCR;;;IA9BvB,sBAAA,CAAuB,KAAA,UAAe,YAAA;IAmCJ;;;IA9BlC,UAAA,CAAW,KAAA,UAAe,KAAA,OAAY,YAAA;IAwCtC;;;IAnCA,iBAAA,CAAkB,KAAA,UAAe,KAAA,OAAY,YAAA;IAwClB;;;IAnC3B,cAAA,CAAe,KAAA,UAAe,KAAA,OAAY,YAAA;IAwCL;;;IAnCrC,qBAAA,CAAsB,KAAA,UAAe,KAAA,OAAY,YAAA;IA6CjD;;;IAxCA,eAAA,CAAgB,KAAA,UAAe,YAAA;IA6CD;;;IAxC9B,sBAAA,CAAuB,KAAA,UAAe,YAAA;IA6CE;;;IAxCxC,kBAAA,CAAmB,KAAA,UAAe,YAAA;IAkDlC;;;IA7CA,yBAAA,CAA0B,KAAA,UAAe,YAAA;IAkDzC;;;IA7CA,kBAAA,CAAmB,MAAA,YAAkB,YAAA;IAkDrC;;;IA7CA,0BAAA,CAA2B,MAAA,YAAkB,YAAA;IAkD7C;;;IA7CA,kBAAA,CAAmB,MAAA,YAAkB,YAAA;IAkDrC;;;IA7CA,0BAAA,CAA2B,MAAA,YAAkB,YAAA;IAkDrB;;;IA7CxB,qBAAA,CAAsB,MAAA,YAAkB,YAAA;IAkDH;;;IA7CrC,6BAAA,CAA8B,MAAA,YAAkB,YAAA;IAuDhD;;;IAlDA,qBAAA,CAAsB,MAAA,YAAkB,YAAA;IAuDhB;;;IAlDxB,6BAAA,CAA8B,MAAA,YAAkB,YAAA;IAuDX;;;IAlDrC,YAAA,CAAa,KAAA,UAAe,MAAA,SAAe,YAAA;IAiF3C;;;IA5EA,mBAAA,CAAoB,KAAA,UAAe,MAAA,SAAe,YAAA;IA6EhD;;;IAxEF,eAAA,CAAgB,KAAA,UAAe,MAAA,SAAe,YAAA;IAyEvB;;;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

@@ -6,7 +6,7 @@ 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 ../seal/src/validators/methods/required-methods.ts
+//#region ../../packages/seal/src/validators/methods/required-methods.ts
 /**
 * Marker re-exported by the validators barrel so the dts bundler keeps this
 * module (and its `declare module` augmentation) in the bundled `.d.ts`.

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

@@ -1 +1 @@
-{"version":3,"file":"required-methods.mjs","names":[],"sources":["../../../../../../../../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\n/**\n * Marker re-exported by the validators barrel so the dts bundler keeps this\n * module (and its `declare module` augmentation) in the bundled `.d.ts`.\n * Without a real export, side-effect-only augmentation modules get tree-shaken\n * out of the published types, dropping every chainable rule method.\n */\nexport const requiredMethodsApplied = true;\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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"}
+{"version":3,"file":"required-methods.mjs","names":[],"sources":["../../../../../../../../../packages/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\n/**\n * Marker re-exported by the validators barrel so the dts bundler keeps this\n * module (and its `declare module` augmentation) in the bundled `.d.ts`.\n * Without a real export, side-effect-only augmentation modules get tree-shaken\n * out of the published types, dropping every chainable rule method.\n */\nexport const requiredMethodsApplied = true;\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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"}

package/esm/validators/number-validator.d.mts

@@ -1,7 +1,7 @@
 import { JsonSchemaResult, JsonSchemaTarget } from "../standard-schema/json-schema.mjs";
 import { PrimitiveValidator } from "./primitive-validator.mjs";
 
-//#region ../seal/src/validators/number-validator.d.ts
+//#region ../../packages/seal/src/validators/number-validator.d.ts
 /**
  * Number validator class - base for Int and Float validators
  */

package/esm/validators/number-validator.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"number-validator.d.mts","names":[],"sources":["../../../../../../../seal/src/validators/number-validator.ts"],"mappings":";;;;;;AA+BA;cAAa,eAAA,SAAwB,kBAAA;cAChB,YAAA;EA6SkB;;;EApS9B,WAAA,CAAY,KAAA;EAVgB;;;;;;EAoB5B,GAAA,CAAI,GAAA,mBAAsB,YAAA;EAVd;;;;;;EAoBZ,GAAA,CAAI,GAAA,mBAAsB,YAAA;EAQ1B;;;;EAAA,UAAA,CAAW,KAAA,UAAe,YAAA;EAQA;;;;EAA1B,UAAA,CAAW,KAAA,UAAe,YAAA;EAuBjB;;;;;;EAbT,WAAA,CAAY,KAAA,mBAAwB,YAAA;EAgCT;;;;;;EAnB3B,QAAA,CAAS,KAAA,mBAAwB,YAAA;EA8CjC;;;;EAnCA,EAAA,CAAG,KAAA,mBAAwB,YAAA;EA8CF;;;;EAtCzB,EAAA,CAAG,KAAA,mBAAwB,YAAA;EAkDf;;;;EA1CZ,kBAAA,CAAmB,KAAA,UAAe,YAAA;EAwDlC;;;;EA7CA,SAAA,CAAU,KAAA,UAAe,YAAA;EAuDzB;;;;EA/CA,eAAA,CAAgB,KAAA,UAAe,YAAA;EAyD1B;;;;EA9CL,SAAA,CAAU,KAAA,UAAe,YAAA;EAoEzB;EA/DA,MAAA,CAAO,KAAA,UAAe,YAAA;EA+DW;;;EAxDjC,WAAA,CAAY,KAAA,UAAe,YAAA;EAsEJ;;;EA/DvB,UAAA,CAAW,KAAA,UAAe,YAAA;EAyE1B;;;EAlEA,SAAA,CAAU,KAAA,UAAe,YAAA;EAkFzB;EA7EA,QAAA,CAAS,YAAA;EA2FT;EAtFA,QAAA,CAAS,YAAA;EAoGT;EA/FA,GAAA,CAAI,YAAA;EAoHJ;EA/GA,IAAA,CAAK,YAAA;EAkII;;;;;;EAxHT,OAAA,CAAQ,GAAA,mBAAsB,GAAA,mBAAsB,YAAA;EAmIzD;;;AACiB;EAxHZ,cAAA,CAAe,QAAA,UAAkB,QAAA,UAAkB,YAAA;;;;;EAcnD,MAAA,CAAO,MAAA,UAAgB,YAAA;;EAKvB,SAAA,CAAU,MAAA,UAAgB,YAAA;;EAK1B,SAAA,CAAU,MAAA,UAAgB,YAAA;;;;EAS1B,GAAA;;;;EAOA,IAAA;;;;EAOA,KAAA;;;;EAOA,KAAA,CAAM,QAAA;;;;;;;;;;;EAcN,OAAA,CAAQ,QAAA;;;;;;;;;;;;;;;;;;EAqBR,MAAA;IAC8C,SAAA;EAAA;;;;;;;;;;;;;;;;EAkBrC,YAAA,CAAa,MAAA,GAAQ,gBAAA,GAAqC,gBAAA;;;;;;YAShE,qBAAA,CACR,IAAA,wBACA,MAAA,EAAQ,gBAAA,GACP,gBAAA;AAAA"}
+{"version":3,"file":"number-validator.d.mts","names":[],"sources":["../../../../../../../../packages/seal/src/validators/number-validator.ts"],"mappings":";;;;;;AA+BA;cAAa,eAAA,SAAwB,kBAAA;cAChB,YAAA;EA6SkB;;;EApS9B,WAAA,CAAY,KAAA;EAVgB;;;;;;EAoB5B,GAAA,CAAI,GAAA,mBAAsB,YAAA;EAVd;;;;;;EAoBZ,GAAA,CAAI,GAAA,mBAAsB,YAAA;EAQ1B;;;;EAAA,UAAA,CAAW,KAAA,UAAe,YAAA;EAQA;;;;EAA1B,UAAA,CAAW,KAAA,UAAe,YAAA;EAuBjB;;;;;;EAbT,WAAA,CAAY,KAAA,mBAAwB,YAAA;EAgCT;;;;;;EAnB3B,QAAA,CAAS,KAAA,mBAAwB,YAAA;EA8CjC;;;;EAnCA,EAAA,CAAG,KAAA,mBAAwB,YAAA;EA8CF;;;;EAtCzB,EAAA,CAAG,KAAA,mBAAwB,YAAA;EAkDf;;;;EA1CZ,kBAAA,CAAmB,KAAA,UAAe,YAAA;EAwDlC;;;;EA7CA,SAAA,CAAU,KAAA,UAAe,YAAA;EAuDzB;;;;EA/CA,eAAA,CAAgB,KAAA,UAAe,YAAA;EAyD1B;;;;EA9CL,SAAA,CAAU,KAAA,UAAe,YAAA;EAoEzB;EA/DA,MAAA,CAAO,KAAA,UAAe,YAAA;EA+DW;;;EAxDjC,WAAA,CAAY,KAAA,UAAe,YAAA;EAsEJ;;;EA/DvB,UAAA,CAAW,KAAA,UAAe,YAAA;EAyE1B;;;EAlEA,SAAA,CAAU,KAAA,UAAe,YAAA;EAkFzB;EA7EA,QAAA,CAAS,YAAA;EA2FT;EAtFA,QAAA,CAAS,YAAA;EAoGT;EA/FA,GAAA,CAAI,YAAA;EAoHJ;EA/GA,IAAA,CAAK,YAAA;EAkII;;;;;;EAxHT,OAAA,CAAQ,GAAA,mBAAsB,GAAA,mBAAsB,YAAA;EAmIzD;;;AACiB;EAxHZ,cAAA,CAAe,QAAA,UAAkB,QAAA,UAAkB,YAAA;;;;;EAcnD,MAAA,CAAO,MAAA,UAAgB,YAAA;;EAKvB,SAAA,CAAU,MAAA,UAAgB,YAAA;;EAK1B,SAAA,CAAU,MAAA,UAAgB,YAAA;;;;EAS1B,GAAA;;;;EAOA,IAAA;;;;EAOA,KAAA;;;;EAOA,KAAA,CAAM,QAAA;;;;;;;;;;;EAcN,OAAA,CAAQ,QAAA;;;;;;;;;;;;;;;;;;EAqBR,MAAA;IAC8C,SAAA;EAAA;;;;;;;;;;;;;;;;EAkBrC,YAAA,CAAa,MAAA,GAAQ,gBAAA,GAAqC,gBAAA;;;;;;YAShE,qBAAA,CACR,IAAA,wBACA,MAAA,EAAQ,gBAAA,GACP,gBAAA;AAAA"}

package/esm/validators/number-validator.mjs

@@ -7,7 +7,7 @@ import { numberRule } from "../rules/common/type-rules.mjs";
 import "../rules/index.mjs";
 import { PrimitiveValidator } from "./primitive-validator.mjs";
 
-//#region ../seal/src/validators/number-validator.ts
+//#region ../../packages/seal/src/validators/number-validator.ts
 /**
 * Number validator class - base for Int and Float validators
 */