@warlock.js/seal 5.30.0 → 5.32.0

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

@@ -1 +1 @@
-{"version":3,"file":"lazy-validator.mjs","names":[],"sources":["../../../../../../../../packages/seal/src/validators/lazy-validator.ts"],"sourcesContent":["import type { JsonSchemaResult, JsonSchemaTarget } from \"../standard-schema/json-schema\";\nimport type { SchemaContext, ValidationResult } from \"../types\";\nimport { BaseValidator } from \"./base-validator\";\n\n/**\n * Lazy validator — defers resolution of the inner validator until validate-time.\n *\n * Solves the chicken-and-egg of self-referencing schemas. JavaScript evaluates\n * an object literal before the `const` binding completes, so this can't work:\n *\n * ```ts\n * const categorySchema = v.object({\n *   name: v.string(),\n *   children: v.array(categorySchema),  // ❌ ReferenceError\n * });\n * ```\n *\n * Wrap the recursive reference in `v.lazy(() => …)` — the thunk isn't invoked\n * during construction, only when `validate()` is called:\n *\n * ```ts\n * type Category = { name: string; children: Category[] };\n *\n * const categorySchema: ObjectValidator<...> = v.object({\n *   name: v.string(),\n *   children: v.array(v.lazy(() => categorySchema)),\n * });\n *\n * type T = Infer<typeof categorySchema>;\n * // { name: string; children: T[] }   ← recursive type\n * ```\n *\n * The thunk is memoized — it's invoked once on the first validate (or\n * `matchesType` / `toJsonSchema`) call and the result is cached. The thunk is\n * expected to return a stable validator; calling it on every validate would be\n * wasteful and could mask bugs where the user accidentally returns a fresh\n * validator each time.\n *\n * **JSON Schema caveat.** v1 uses simple resolve-and-delegate — recursive\n * schemas will infinite-loop in `toJsonSchema()`. If you need JSON Schema for\n * a recursive shape, generate it manually with `$defs` + `$ref` until v2 lands.\n *\n * @see `domains/seal/plans/2026-05-12-lazy-validator.md`\n */\nexport class LazyValidator<T extends BaseValidator = BaseValidator> extends BaseValidator {\n  private resolvedValidator: T | undefined;\n\n  public constructor(private thunk: () => T) {\n    super();\n    // Lazy itself defers required handling to the inner validator —\n    // mark the wrapper as optional so the required check doesn't fire here.\n    this.requiredRule = null;\n    this.isOptional = true;\n  }\n\n  /**\n   * Resolve the inner validator. Memoizes the result so subsequent calls\n   * don't re-execute the thunk.\n   */\n  private resolve(): T {\n    if (this.resolvedValidator === undefined) {\n      this.resolvedValidator = this.thunk();\n    }\n\n    return this.resolvedValidator;\n  }\n\n  public override async validate(data: any, context: SchemaContext): Promise<ValidationResult> {\n    return this.resolve().validate(data, context);\n  }\n\n  public override matchesType(value: any): boolean {\n    return this.resolve().matchesType(value);\n  }\n\n  public override clone(): this {\n    const cloned = super.clone();\n    // Share the thunk reference; reset the memo so the clone resolves\n    // independently on its first call (in case the thunk closure resolves\n    // differently in a different context — unlikely but cheap insurance).\n    cloned.thunk = this.thunk;\n    cloned.resolvedValidator = undefined;\n\n    return cloned;\n  }\n\n  /**\n   * JSON Schema generation — simple resolve-and-delegate.\n   *\n   * **Recursive schemas will infinite-loop.** Until v2 adds `$ref` + `$defs`\n   * generation, callers needing JSON Schema for recursive shapes must build\n   * the schema manually.\n   */\n  public override toJsonSchema(target: JsonSchemaTarget = \"draft-2020-12\"): JsonSchemaResult {\n    return this.resolve().toJsonSchema(target);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4CA,IAAa,gBAAb,cAA4E,cAAc;CAGxF,AAAO,YAAY,AAAQ,OAAgB;EACzC,MAAM;EADmB;EAIzB,KAAK,eAAe;EACpB,KAAK,aAAa;CACpB;;;;;CAMA,AAAQ,UAAa;EACnB,IAAI,KAAK,sBAAsB,QAC7B,KAAK,oBAAoB,KAAK,MAAM;EAGtC,OAAO,KAAK;CACd;CAEA,MAAsB,SAAS,MAAW,SAAmD;EAC3F,OAAO,KAAK,QAAQ,CAAC,CAAC,SAAS,MAAM,OAAO;CAC9C;CAEA,AAAgB,YAAY,OAAqB;EAC/C,OAAO,KAAK,QAAQ,CAAC,CAAC,YAAY,KAAK;CACzC;CAEA,AAAgB,QAAc;EAC5B,MAAM,SAAS,MAAM,MAAM;EAI3B,OAAO,QAAQ,KAAK;EACpB,OAAO,oBAAoB;EAE3B,OAAO;CACT;;;;;;;;CASA,AAAgB,aAAa,SAA2B,iBAAmC;EACzF,OAAO,KAAK,QAAQ,CAAC,CAAC,aAAa,MAAM;CAC3C;AACF"}
+{"version":3,"file":"lazy-validator.mjs","names":[],"sources":["../../../../../../../../packages/seal/src/validators/lazy-validator.ts"],"sourcesContent":["import type { JsonSchemaResult, JsonSchemaTarget } from \"../standard-schema/json-schema\";\nimport type { SchemaContext, ValidationResult } from \"../types\";\nimport { BaseValidator } from \"./base-validator\";\n\n/**\n * Lazy validator — defers resolution of the inner validator until validate-time.\n *\n * Solves the chicken-and-egg of self-referencing schemas. JavaScript evaluates\n * an object literal before the `const` binding completes, so this can't work:\n *\n * ```ts\n * const categorySchema = v.object({\n *   name: v.string(),\n *   children: v.array(categorySchema),  // ❌ ReferenceError\n * });\n * ```\n *\n * Wrap the recursive reference in `v.lazy(() => …)` — the thunk isn't invoked\n * during construction, only when `validate()` is called:\n *\n * ```ts\n * type Category = { name: string; children: Category[] };\n *\n * const categorySchema: ObjectValidator<...> = v.object({\n *   name: v.string(),\n *   children: v.array(v.lazy(() => categorySchema)),\n * });\n *\n * type T = Infer<typeof categorySchema>;\n * // { name: string; children: T[] }   ← recursive type\n * ```\n *\n * The thunk is memoized — it's invoked once on the first validate (or\n * `matchesType` / `toJsonSchema`) call and the result is cached. The thunk is\n * expected to return a stable validator; calling it on every validate would be\n * wasteful and could mask bugs where the user accidentally returns a fresh\n * validator each time.\n *\n * **JSON Schema caveat.** v1 uses simple resolve-and-delegate — recursive\n * schemas will infinite-loop in `toJsonSchema()`. If you need JSON Schema for\n * a recursive shape, generate it manually with `$defs` + `$ref` until v2 lands.\n *\n * @see `domains/seal/plans/2026-05-12-lazy-validator.md`\n */\nexport class LazyValidator<T extends BaseValidator = BaseValidator> extends BaseValidator {\n  private resolvedValidator: T | undefined;\n\n  public constructor(private thunk: () => T) {\n    super();\n    // Lazy itself defers required handling to the inner validator —\n    // mark the wrapper as optional so the required check doesn't fire here.\n    this.requiredRule = null;\n    this.isOptional = true;\n  }\n\n  /**\n   * Resolve the inner validator. Memoizes the result so subsequent calls\n   * don't re-execute the thunk.\n   */\n  private resolve(): T {\n    if (this.resolvedValidator === undefined) {\n      this.resolvedValidator = this.thunk();\n    }\n\n    return this.resolvedValidator;\n  }\n\n  public override async validate(data: any, context: SchemaContext): Promise<ValidationResult> {\n    return this.refineResult(await this.resolve().validate(data, context), context);\n  }\n\n  public override matchesType(value: any): boolean {\n    return this.resolve().matchesType(value);\n  }\n\n  public override clone(): this {\n    const cloned = super.clone();\n    // Share the thunk reference; reset the memo so the clone resolves\n    // independently on its first call (in case the thunk closure resolves\n    // differently in a different context — unlikely but cheap insurance).\n    cloned.thunk = this.thunk;\n    cloned.resolvedValidator = undefined;\n\n    return cloned;\n  }\n\n  /**\n   * JSON Schema generation — simple resolve-and-delegate.\n   *\n   * **Recursive schemas will infinite-loop.** Until v2 adds `$ref` + `$defs`\n   * generation, callers needing JSON Schema for recursive shapes must build\n   * the schema manually.\n   */\n  public override toJsonSchema(target: JsonSchemaTarget = \"draft-2020-12\"): JsonSchemaResult {\n    return this.resolve().toJsonSchema(target);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4CA,IAAa,gBAAb,cAA4E,cAAc;CAGxF,AAAO,YAAY,AAAQ,OAAgB;EACzC,MAAM;EADmB;EAIzB,KAAK,eAAe;EACpB,KAAK,aAAa;CACpB;;;;;CAMA,AAAQ,UAAa;EACnB,IAAI,KAAK,sBAAsB,QAC7B,KAAK,oBAAoB,KAAK,MAAM;EAGtC,OAAO,KAAK;CACd;CAEA,MAAsB,SAAS,MAAW,SAAmD;EAC3F,OAAO,KAAK,aAAa,MAAM,KAAK,QAAQ,CAAC,CAAC,SAAS,MAAM,OAAO,GAAG,OAAO;CAChF;CAEA,AAAgB,YAAY,OAAqB;EAC/C,OAAO,KAAK,QAAQ,CAAC,CAAC,YAAY,KAAK;CACzC;CAEA,AAAgB,QAAc;EAC5B,MAAM,SAAS,MAAM,MAAM;EAI3B,OAAO,QAAQ,KAAK;EACpB,OAAO,oBAAoB;EAE3B,OAAO;CACT;;;;;;;;CASA,AAAgB,aAAa,SAA2B,iBAAmC;EACzF,OAAO,KAAK,QAAQ,CAAC,CAAC,aAAa,MAAM;CAC3C;AACF"}

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

@@ -1,6 +1,5 @@
 import { JsonSchemaResult, JsonSchemaTarget } from "../standard-schema/json-schema.mjs";
 import { BaseValidator } from "./base-validator.mjs";
-
 //#region ../../packages/seal/src/validators/literal-validator.d.ts
 /**
  * Literal validator class
@@ -16,7 +15,7 @@ import { BaseValidator } from "./base-validator.mjs";
  * v.literal(1, 2, 3)               // type: 1 | 2 | 3
  * v.literal(true)                  // type: true
  */
-declare class LiteralValidator<T extends readonly (string | number | boolean)[] = readonly (string | number | boolean)[]> extends BaseValidator {
+export declare class LiteralValidator<T extends readonly (string | number | boolean)[] = readonly (string | number | boolean)[]> extends BaseValidator {
   values: T;
   constructor(values: T, errorMessage?: string);
   /**
@@ -48,5 +47,4 @@ declare class LiteralValidator<T extends readonly (string | number | boolean)[]
   toJsonSchema(target?: JsonSchemaTarget): JsonSchemaResult;
 }
 //#endregion
-export { LiteralValidator };
 //# sourceMappingURL=literal-validator.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"literal-validator.d.mts","names":[],"sources":["../../../../../../../../packages/seal/src/validators/literal-validator.ts"],"mappings":";;;;;;AAoBA;;;;;;;;;;;;cAAa,gBAAA,oGAEH,aAAA;EACD,MAAA,EAAQ,CAAA;cAEI,MAAA,EAAQ,CAAA,EAAG,YAAA;EAAH;;;EAyBpB,WAAA,CAAY,KAAA;EAAA;;;;;;;EAWH,KAAA;;;;;;;;;;;;;;;EAoBA,YAAA,CAAa,MAAA,GAAQ,gBAAA,GAAqC,gBAAA;AAAA"}
+{"version":3,"file":"literal-validator.d.mts","names":[],"sources":["../../../../../../../../packages/seal/src/validators/literal-validator.ts"],"mappings":";;;;;;;;;;;;;;;;;qBAoBa,iBACX,mGACQ;EACD,QAAQ;EAEf,YAAmB,QAAQ,GAAG;;;;EAyBvB,YAAY;;;;;;;;EAWH;;;;;;;;;;;;;;;EAoBA,aAAa,SAAQ,mBAAqC"}

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

@@ -1,13 +1,13 @@
 import { SchemaContext } from "../types/context-types.mjs";
+import "../types/index.mjs";
 import { BaseValidator } from "./base-validator.mjs";
 import { ComputedValidator } from "./computed-validator.mjs";
-
 //#region ../../packages/seal/src/validators/managed-validator.d.ts
 /**
  * Callback function for managed fields
  * Receives only schema context (no data dependency)
  */
-type ManagedCallback<TResult = any> = (context: SchemaContext) => TResult | Promise<TResult>;
+export type ManagedCallback<TResult = any> = (context: SchemaContext) => TResult | Promise<TResult>;
 /**
  * Managed field validator
  *
@@ -28,7 +28,7 @@ type ManagedCallback<TResult = any> = (context: SchemaContext) => TResult | Prom
  * });
  * ```
  */
-declare class ManagedValidator<TResult = any> extends ComputedValidator<TResult> {
+export declare class ManagedValidator<TResult = any> extends ComputedValidator<TResult> {
   /**
    * Create a new managed field validator
    *
@@ -38,5 +38,4 @@ declare class ManagedValidator<TResult = any> extends ComputedValidator<TResult>
   constructor(callback: ManagedCallback<TResult>, resultValidator?: BaseValidator);
 }
 //#endregion
-export { ManagedCallback, ManagedValidator };
 //# sourceMappingURL=managed-validator.d.mts.map

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

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"managed-validator.d.mts","names":[],"sources":["../../../../../../../../packages/seal/src/validators/managed-validator.ts"],"mappings":";;;;;;;;;YAQY,gBAAgB,kBAAkB,SAAS,kBAAkB,UAAU,QAAQ;;;;;;;;;;;;;;;;;;;;;qBAsB9E,iBAAiB,uBAAuB,kBAAkB;;;;;;;EAOrE,YAAY,UAAU,gBAAgB,UAAU,kBAAkB"}

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

@@ -1,11 +1,11 @@
 import { WhenRuleOptions } from "../../types/conditional-types.mjs";
-
+import "../../types/index.mjs";
 //#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`.
  */
-declare const equalityConditionalMethodsApplied = true;
+export declare const equalityConditionalMethodsApplied = true;
 declare module "../base-validator.mjs" {
   interface BaseValidator {
     /**
@@ -91,7 +91,6 @@ declare module "../base-validator.mjs" {
      */
     whenSibling(siblingField: string, options: Omit<WhenRuleOptions, "field" | "scope">): this;
   }
-} //# sourceMappingURL=equality-conditional-methods.d.ts.map
+}
 //#endregion
-export { equalityConditionalMethodsApplied };
 //# sourceMappingURL=equality-conditional-methods.d.mts.map

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

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"equality-conditional-methods.d.mts","names":[],"sources":["../../../../../../../../../packages/seal/src/validators/methods/equality-conditional-methods.ts"],"mappings":";;;;;;;qBAUa;;YAGD;;;;IAIR,MAAM,YAAY;;;;IAKlB,OAAO,eAAe;;;;IAKtB,cAAc,eAAe;;;;IAK7B,cAAc,eAAe;;;;IAK7B,qBAAqB,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAsCpC,KAAK,eAAe,SAAS,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;IA0BlC,YAAY,sBAAsB,SAAS,KAAK"}

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

@@ -3,7 +3,7 @@
  * Marker re-exported by the validators barrel so the dts bundler keeps this
  * module (and its `declare module` augmentation) in the bundled `.d.ts`.
  */
-declare const forbiddenMethodsApplied = true;
+export declare const forbiddenMethodsApplied = true;
 declare module "../base-validator.mjs" {
   interface BaseValidator {
     /**
@@ -59,7 +59,6 @@ declare module "../base-validator.mjs" {
      */
     forbiddenIfNotInSibling(field: string, values: any[], errorMessage?: string): this;
   }
-} //# sourceMappingURL=forbidden-methods.d.ts.map
+}
 //#endregion
-export { forbiddenMethodsApplied };
 //# sourceMappingURL=forbidden-methods.d.mts.map

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

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"forbidden-methods.d.mts","names":[],"sources":["../../../../../../../../../packages/seal/src/validators/methods/forbidden-methods.ts"],"mappings":";;;;;qBAea;;YAGD;;;;IAIR,UAAU;;;;IAKV,YAAY,eAAe,YAAY;;;;IAKvC,mBAAmB,eAAe,YAAY;;;;IAK9C,eAAe,eAAe,YAAY;;;;IAK1C,sBAAsB,eAAe,YAAY;;;;IAKjD,iBAAiB,eAAe;;;;IAKhC,wBAAwB,eAAe;;;;IAKvC,oBAAoB,eAAe;;;;IAKnC,2BAA2B,eAAe;;;;IAK1C,cAAc,eAAe,eAAe;;;;IAK5C,qBAAqB,eAAe,eAAe;;;;IAKnD,iBAAiB,eAAe,eAAe;;;;IAK/C,wBAAwB,eAAe,eAAe"}

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

@@ -3,7 +3,7 @@
  * Marker re-exported by the validators barrel so the dts bundler keeps this
  * module (and its `declare module` augmentation) in the bundled `.d.ts`.
  */
-declare const presentMethodsApplied = true;
+export declare const presentMethodsApplied = true;
 declare module "../base-validator.mjs" {
   interface BaseValidator {
     /**
@@ -103,7 +103,6 @@ declare module "../base-validator.mjs" {
      */
     presentWithoutAnySiblings(fields: string[], errorMessage?: string): this;
   }
-} //# sourceMappingURL=present-methods.d.ts.map
+}
 //#endregion
-export { presentMethodsApplied };
 //# sourceMappingURL=present-methods.d.mts.map

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

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"present-methods.d.mts","names":[],"sources":["../../../../../../../../../packages/seal/src/validators/methods/present-methods.ts"],"mappings":";;;;;qBAwBa;;YAGD;;;;IAIR,YAAY,eAAe;;;;IAK3B,mBAAmB,eAAe;;;;IAKlC,eAAe,eAAe;;;;IAK9B,sBAAsB,eAAe;;;;IAKrC,UAAU,eAAe,YAAY;;;;IAKrC,iBAAiB,eAAe,YAAY;;;;IAK5C,cAAc,eAAe,YAAY;;;;IAKzC,qBAAqB,eAAe,YAAY;;;;IAKhD,eAAe,eAAe;;;;IAK9B,sBAAsB,eAAe;;;;IAKrC,kBAAkB,eAAe;;;;IAKjC,yBAAyB,eAAe;;;;IAKxC,YAAY,eAAe,eAAe;;;;IAK1C,mBAAmB,eAAe,eAAe;;;;IAKjD,eAAe,eAAe,eAAe;;;;IAK7C,sBAAsB,eAAe,eAAe;;;;IAKpD,eAAe,kBAAkB;;;;IAKjC,uBAAuB,kBAAkB;;;;IAKzC,kBAAkB,kBAAkB;;;;IAKpC,0BAA0B,kBAAkB;;;;IAK5C,eAAe,kBAAkB;;;;IAKjC,uBAAuB,kBAAkB;;;;IAKzC,kBAAkB,kBAAkB;;;;IAKpC,0BAA0B,kBAAkB"}

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

@@ -1,5 +1,5 @@
 import { SchemaContext } from "../../types/context-types.mjs";
-
+import "../../types/index.mjs";
 //#region ../../packages/seal/src/validators/methods/required-methods.d.ts
 /**
  * Marker re-exported by the validators barrel so the dts bundler keeps this
@@ -7,7 +7,7 @@ import { SchemaContext } from "../../types/context-types.mjs";
  * Without a real export, side-effect-only augmentation modules get tree-shaken
  * out of the published types, dropping every chainable rule method.
  */
-declare const requiredMethodsApplied = true;
+export declare const requiredMethodsApplied = true;
 declare module "../base-validator.mjs" {
   interface BaseValidator {
     /**
@@ -196,7 +196,6 @@ declare module "../base-validator.mjs" {
      */
     requiredWhen(callback: (context: SchemaContext) => boolean | Promise<boolean>, errorMessage?: string): this;
   }
-} //# sourceMappingURL=required-methods.d.ts.map
+}
 //#endregion
-export { requiredMethodsApplied };
 //# sourceMappingURL=required-methods.d.mts.map

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

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"required-methods.d.mts","names":[],"sources":["../../../../../../../../../packages/seal/src/validators/methods/required-methods.ts"],"mappings":";;;;;;;;;qBAiCa;;YAGD;;;;IAIR,SAAS;;;;IAKT,QAAQ;;;;;IAMR;MAAqB;;;;;;;;;;;;;;;IAerB;MAAoB;MAAkB;;;;;IAKtC,aAAa,eAAe;;;;IAK5B,oBAAoB,eAAe;;;;IAKnC,gBAAgB,eAAe;;;;IAK/B,uBAAuB,eAAe;;;;IAKtC,WAAW,eAAe,YAAY;;;;IAKtC,kBAAkB,eAAe,YAAY;;;;IAK7C,eAAe,eAAe,YAAY;;;;IAK1C,sBAAsB,eAAe,YAAY;;;;IAKjD,gBAAgB,eAAe;;;;IAK/B,uBAAuB,eAAe;;;;IAKtC,mBAAmB,eAAe;;;;IAKlC,0BAA0B,eAAe;;;;IAKzC,mBAAmB,kBAAkB;;;;IAKrC,2BAA2B,kBAAkB;;;;IAK7C,mBAAmB,kBAAkB;;;;IAKrC,2BAA2B,kBAAkB;;;;IAK7C,sBAAsB,kBAAkB;;;;IAKxC,8BAA8B,kBAAkB;;;;IAKhD,sBAAsB,kBAAkB;;;;IAKxC,8BAA8B,kBAAkB;;;;IAKhD,aAAa,eAAe,eAAe;;;;IAK3C,oBAAoB,eAAe,eAAe;;;;IAKlD,gBAAgB,eAAe,eAAe;;;;IAK9C,uBAAuB,eAAe,eAAe;;;;IAKrD,gBAAgB,kBAAkB;;;;IAKlC,wBAAwB,kBAAkB;;;;IAK1C,mBAAmB,kBAAkB;;;;IAKrC,2BAA2B,kBAAkB;;;;IAK7C,gBAAgB,kBAAkB;;;;IAKlC,wBAAwB,kBAAkB;;;;IAK1C,mBAAmB,kBAAkB;;;;IAKrC,2BAA2B,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;IA0B7C,aACE,WAAW,SAAS,4BAA4B,kBAChD"}

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

@@ -1,11 +1,10 @@
 import { JsonSchemaResult, JsonSchemaTarget } from "../standard-schema/json-schema.mjs";
 import { PrimitiveValidator } from "./primitive-validator.mjs";
-
 //#region ../../packages/seal/src/validators/number-validator.d.ts
 /**
  * Number validator class - base for Int and Float validators
  */
-declare class NumberValidator extends PrimitiveValidator {
+export declare class NumberValidator extends PrimitiveValidator {
   constructor(errorMessage?: string);
   /**
    * Check if value is a number type
@@ -193,5 +192,4 @@ declare class NumberValidator extends PrimitiveValidator {
   protected buildNumberJsonSchema(type: "number" | "integer", target: JsonSchemaTarget): JsonSchemaResult;
 }
 //#endregion
-export { NumberValidator };
 //# sourceMappingURL=number-validator.d.mts.map

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

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"number-validator.d.mts","names":[],"sources":["../../../../../../../../packages/seal/src/validators/number-validator.ts"],"mappings":";;;;;;qBA+Ba,wBAAwB;EACnC,YAAmB;;;;EASZ,YAAY;;;;;;;EAUZ,IAAI,sBAAsB;;;;;;;EAU1B,IAAI,sBAAsB;;;;;EAQ1B,WAAW,eAAe;;;;;EAQ1B,WAAW,eAAe;;;;;;;EAU1B,YAAY,wBAAwB;;;;;;;EAapC,SAAS,wBAAwB;;;;;EAWjC,GAAG,wBAAwB;;;;;EAQ3B,GAAG,wBAAwB;;;;;EAQ3B,mBAAmB,eAAe;;;;;EAWlC,UAAU,eAAe;;;;;EAQzB,gBAAgB,eAAe;;;;;EAW/B,UAAU,eAAe;;EAKzB,OAAO,eAAe;;;;EAOtB,YAAY,eAAe;;;;EAO3B,WAAW,eAAe;;;;EAO1B,UAAU,eAAe;;EAKzB,SAAS;;EAKT,SAAS;;EAKT,IAAI;;EAKJ,KAAK;;;;;;;EAUL,QAAQ,sBAAsB,sBAAsB;;;;;EAYpD,eAAe,kBAAkB,kBAAkB;;;;;EAcnD,OAAO,gBAAgB;;EAKvB,UAAU,gBAAgB;;EAK1B,UAAU,gBAAgB;;;;EAS1B;;;;EAOA;;;;EAOA;;;;EAOA,MAAM;;;;;;;;;;;EAcN,QAAQ;;;;;;;;;;;;;;;;;;EAqBR;IAC8C;;;;;;;;;;;;;;;;;EAkBrC,aAAa,SAAQ,mBAAqC;;;;;;YAShE,sBACR,4BACA,QAAQ,mBACP"}

package/esm/validators/number-validator.mjs

@@ -308,15 +308,19 @@ var NumberValidator = class extends PrimitiveValidator {
 			if (typeof betweenOpts.max === "number") schema.maximum = betweenOpts.max;
 		}
 		const gtOpts = getRuleOptions(this.rules, "greaterThan");
-		if (gtOpts?.value !== void 0 && typeof gtOpts.value === "number") if (target === "draft-07") {
-			schema.minimum = gtOpts.value;
-			schema.exclusiveMinimum = true;
-		} else schema.exclusiveMinimum = gtOpts.value;
+		if (gtOpts?.value !== void 0 && typeof gtOpts.value === "number") {
+			if (target === "draft-07") {
+				schema.minimum = gtOpts.value;
+				schema.exclusiveMinimum = true;
+			} else schema.exclusiveMinimum = gtOpts.value;
+		}
 		const ltOpts = getRuleOptions(this.rules, "lessThan");
-		if (ltOpts?.value !== void 0 && typeof ltOpts.value === "number") if (target === "draft-07") {
-			schema.maximum = ltOpts.value;
-			schema.exclusiveMaximum = true;
-		} else schema.exclusiveMaximum = ltOpts.value;
+		if (ltOpts?.value !== void 0 && typeof ltOpts.value === "number") {
+			if (target === "draft-07") {
+				schema.maximum = ltOpts.value;
+				schema.exclusiveMaximum = true;
+			} else schema.exclusiveMaximum = ltOpts.value;
+		}
 		const moduloOpts = getRuleOptions(this.rules, "modulo");
 		if (moduloOpts?.value !== void 0 && typeof moduloOpts.value === "number") schema.multipleOf = moduloOpts.value;
 		const inOpts = getRuleOptions(this.rules, "in");

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

@@ -1 +1 @@
-{"version":3,"file":"number-validator.mjs","names":[],"sources":["../../../../../../../../packages/seal/src/validators/number-validator.ts"],"sourcesContent":["import {\n  absMutator,\n  ceilMutator,\n  floorMutator,\n  numericMutator,\n  roundMutator,\n  toFixedMutator,\n} from \"../mutators\";\nimport {\n  betweenNumbersRule,\n  evenRule,\n  greaterThanRule,\n  lengthRule,\n  lessThanRule,\n  maxLengthRule,\n  maxRule,\n  minLengthRule,\n  minRule,\n  moduloRule,\n  negativeRule,\n  numberRule,\n  oddRule,\n  positiveRule,\n} from \"../rules\";\nimport { PrimitiveValidator } from \"./primitive-validator\";\nimport { applyNullable, getRuleOptions } from \"../standard-schema/json-schema\";\nimport type { JsonSchemaResult, JsonSchemaTarget } from \"../standard-schema/json-schema\";\n\n/**\n * Number validator class - base for Int and Float validators\n */\nexport class NumberValidator extends PrimitiveValidator {\n  public constructor(errorMessage?: string) {\n    super();\n    this.blankIsMissing = true;\n    this.addMutableRule(numberRule, errorMessage);\n  }\n\n  /**\n   * Check if value is a number type\n   */\n  public matchesType(value: any): boolean {\n    return typeof value === \"number\" && !isNaN(value);\n  }\n\n  /**\n   * Value must be equal or higher than the given number or field\n   * Smart detection: number or field name\n   *\n   * @category Validation Rule\n   */\n  public min(min: number | string, errorMessage?: string) {\n    return this.addRule(minRule, errorMessage, { min, scope: \"global\" });\n  }\n\n  /**\n   * Value must be equal or less than the given number or field\n   * Smart detection: number or field name\n   *\n   * @category Validation Rule\n   */\n  public max(max: number | string, errorMessage?: string) {\n    return this.addRule(maxRule, errorMessage, { max, scope: \"global\" });\n  }\n\n  /**\n   * Value must be >= sibling field value\n   * @category Validation Rule\n   */\n  public minSibling(field: string, errorMessage?: string) {\n    return this.addRule(minRule, errorMessage, { min: field, scope: \"sibling\" });\n  }\n\n  /**\n   * Value must be <= sibling field value\n   * @category Validation Rule\n   */\n  public maxSibling(field: string, errorMessage?: string) {\n    return this.addRule(maxRule, errorMessage, { max: field, scope: \"sibling\" });\n  }\n\n  /**\n   * Value must be strictly greater than the given number or field (>)\n   * Smart detection: number or field name\n   *\n   * @category Validation Rule\n   */\n  public greaterThan(value: number | string, errorMessage?: string) {\n    return this.addRule(greaterThanRule, errorMessage, {\n      value,\n      scope: \"global\",\n    });\n  }\n\n  /**\n   * Value must be strictly less than the given number or field (<)\n   * Smart detection: number or field name\n   *\n   * @category Validation Rule\n   */\n  public lessThan(value: number | string, errorMessage?: string) {\n    return this.addRule(lessThanRule, errorMessage, {\n      value,\n      scope: \"global\",\n    });\n  }\n\n  /**\n   * Alias for greaterThan() - shorter syntax\n   * @category Validation Rule\n   */\n  public gt(value: number | string, errorMessage?: string) {\n    return this.greaterThan(value, errorMessage);\n  }\n\n  /**\n   * Alias for lessThan() - shorter syntax\n   * @category Validation Rule\n   */\n  public lt(value: number | string, errorMessage?: string) {\n    return this.lessThan(value, errorMessage);\n  }\n\n  /**\n   * Value must be > sibling field value\n   * @category Validation Rule\n   */\n  public greaterThanSibling(field: string, errorMessage?: string) {\n    return this.addRule(greaterThanRule, errorMessage, {\n      value: field,\n      scope: \"sibling\",\n    });\n  }\n\n  /**\n   * Alias for greaterThanSibling() - shorter syntax\n   * @category Validation Rule\n   */\n  public gtSibling(field: string, errorMessage?: string) {\n    return this.greaterThanSibling(field, errorMessage);\n  }\n\n  /**\n   * Value must be < sibling field value\n   * @category Validation Rule\n   */\n  public lessThanSibling(field: string, errorMessage?: string) {\n    return this.addRule(lessThanRule, errorMessage, {\n      value: field,\n      scope: \"sibling\",\n    });\n  }\n\n  /**\n   * Alias for lessThanSibling() - shorter syntax\n   * @category Validation Rule\n   */\n  public ltSibling(field: string, errorMessage?: string) {\n    return this.lessThanSibling(field, errorMessage);\n  }\n\n  /** Value must be a modulo of the given number */\n  public modulo(value: number, errorMessage?: string) {\n    return this.addRule(moduloRule, errorMessage, { value });\n  }\n\n  /**\n   * Alias for modulo() - Value must be divisible by the given number\n   */\n  public divisibleBy(value: number, errorMessage?: string) {\n    return this.modulo(value, errorMessage);\n  }\n\n  /**\n   * Alias for modulo() - Value must be a multiple of the given number\n   */\n  public multipleOf(value: number, errorMessage?: string) {\n    return this.modulo(value, errorMessage);\n  }\n\n  /**\n   * Alias for modulo() - Value must be a multiple of the given number\n   */\n  public modulusOf(value: number, errorMessage?: string) {\n    return this.modulo(value, errorMessage);\n  }\n\n  /** Accept only numbers higher than 0 */\n  public positive(errorMessage?: string) {\n    return this.addRule(positiveRule, errorMessage);\n  }\n\n  /** Accept only negative numbers */\n  public negative(errorMessage?: string) {\n    return this.addRule(negativeRule, errorMessage);\n  }\n\n  /** Accept only odd numbers */\n  public odd(errorMessage?: string) {\n    return this.addRule(oddRule, errorMessage);\n  }\n\n  /** Accept only even numbers */\n  public even(errorMessage?: string) {\n    return this.addRule(evenRule, errorMessage);\n  }\n\n  /**\n   * Accept only numbers between the given two numbers or fields (Inclusive)\n   * Smart detection: number or field name\n   *\n   * @category Validation Rule\n   */\n  public between(min: number | string, max: number | string, errorMessage?: string) {\n    return this.addRule(betweenNumbersRule, errorMessage, {\n      min,\n      max,\n      scope: \"global\",\n    });\n  }\n\n  /**\n   * Value must be between sibling field values\n   * @category Validation Rule\n   */\n  public betweenSibling(minField: string, maxField: string, errorMessage?: string) {\n    return this.addRule(betweenNumbersRule, errorMessage, {\n      min: minField,\n      max: maxField,\n      scope: \"sibling\",\n    });\n  }\n\n  // Enum and value membership methods are inherited from PrimitiveValidator.\n\n  /**\n   * Value (as a string) must be exactly this many characters.\n   * Useful for fixed-format numeric codes (e.g. 4-digit PIN).\n   */\n  public length(length: number, errorMessage?: string) {\n    return this.addRule(lengthRule, errorMessage, { length });\n  }\n\n  /** Value (as string representation) length must be ≥ min */\n  public minLength(length: number, errorMessage?: string) {\n    return this.addRule(minLengthRule, errorMessage, { minLength: length });\n  }\n\n  /** Value (as string representation) length must be ≤ max */\n  public maxLength(length: number, errorMessage?: string) {\n    return this.addRule(maxLengthRule, errorMessage, { maxLength: length });\n  }\n\n  // Mutators\n\n  /**\n   * Convert value to its absolute value\n   */\n  public abs() {\n    return this.addMutator(absMutator);\n  }\n\n  /**\n   * Round value up to the nearest integer\n   */\n  public ceil() {\n    return this.addMutator(ceilMutator);\n  }\n\n  /**\n   * Round value down to the nearest integer\n   */\n  public floor() {\n    return this.addMutator(floorMutator);\n  }\n\n  /**\n   * Round value to the nearest integer or specified decimals\n   */\n  public round(decimals = 0) {\n    return this.addMutator(roundMutator, { decimals });\n  }\n\n  /**\n   * Round to a fixed number of decimal places, keeping the value a **number**.\n   *\n   * `v.number().toFixed(2)` on `3.14159` yields `3.14`, not `\"3.14\"` — a number\n   * schema has to output a number, or its own type rule rejects the result.\n   * Format to a fixed-point *string* at the presentation edge instead.\n   *\n   * @example\n   * v.number().toFixed(2)   // 3.14159 → 3.14\n   */\n  public toFixed(decimals = 2) {\n    return this.addMutator(toFixedMutator, { decimals });\n  }\n\n  /**\n   * Opt in to coercion: a numeric-shaped string is converted to a number\n   * **before** the type rules run; any other value passes through unchanged\n   * so bad input still fails the type rule.\n   *\n   * Strictness is preserved — coercion only fixes the string *representation*,\n   * not the value's shape. `v.int().coerce()` turns `\"5\"` into `5` (valid) but\n   * `\"5.5\"` into `5.5`, which still fails the integer rule. Number validators\n   * do **not** coerce by default; this only takes effect when explicitly chained.\n   *\n   * The output type is unchanged (`Infer<>` keys off the validator class), so\n   * `v.int().coerce()` still infers `number`.\n   *\n   * @example\n   * v.int().coerce()      // \"5\" → 5 (valid); \"5.5\" → 5.5 (invalid); \"abc\" → invalid\n   * v.number().coerce()   // \"5.5\" → 5.5 (valid)\n   */\n  public coerce() {\n    return this.addMutator(numericMutator) as this & { isCoerced: true };\n  }\n\n  /**\n   * @inheritdoc\n   *\n   * Returns `{ type: \"number\" }` with numeric constraint keywords.\n   * IntValidator overrides `type` to `\"integer\"`.\n   *\n   * @note Sibling-scoped rules (minSibling, maxSibling, etc.) are not representable\n   * in JSON Schema and are silently omitted.\n   *\n   * @example\n   * ```ts\n   * v.number().min(0).max(100).toJsonSchema(\"draft-2020-12\")\n   * // → { type: \"number\", minimum: 0, maximum: 100 }\n   * ```\n   */\n  public override toJsonSchema(target: JsonSchemaTarget = \"draft-2020-12\"): JsonSchemaResult {\n    return this.buildNumberJsonSchema(\"number\", target);\n  }\n\n  /**\n   * Shared logic for number/integer JSON Schema generation.\n   * Called by NumberValidator.toJsonSchema() (→ type: \"number\")\n   * and IntValidator.toJsonSchema() (→ type: \"integer\").\n   */\n  protected buildNumberJsonSchema(\n    type: \"number\" | \"integer\",\n    target: JsonSchemaTarget,\n  ): JsonSchemaResult {\n    const schema: JsonSchemaResult = { type };\n\n    // minimum (inclusive)\n    const minOpts = getRuleOptions(this.rules, \"min\");\n    if (minOpts?.min !== undefined && typeof minOpts.min === \"number\") {\n      schema.minimum = minOpts.min;\n    }\n\n    // maximum (inclusive)\n    const maxOpts = getRuleOptions(this.rules, \"max\");\n    if (maxOpts?.max !== undefined && typeof maxOpts.max === \"number\") {\n      schema.maximum = maxOpts.max;\n    }\n\n    // between (inclusive range)\n    const betweenOpts = getRuleOptions(this.rules, \"betweenNumbers\");\n    if (betweenOpts) {\n      if (typeof betweenOpts.min === \"number\") schema.minimum = betweenOpts.min;\n      if (typeof betweenOpts.max === \"number\") schema.maximum = betweenOpts.max;\n    }\n\n    // greaterThan (>) → exclusiveMinimum\n    const gtOpts = getRuleOptions(this.rules, \"greaterThan\");\n    if (gtOpts?.value !== undefined && typeof gtOpts.value === \"number\") {\n      if (target === \"draft-07\") {\n        schema.minimum = gtOpts.value;\n        schema.exclusiveMinimum = true;\n      } else {\n        schema.exclusiveMinimum = gtOpts.value;\n      }\n    }\n\n    // lessThan (<) → exclusiveMaximum\n    const ltOpts = getRuleOptions(this.rules, \"lessThan\");\n    if (ltOpts?.value !== undefined && typeof ltOpts.value === \"number\") {\n      if (target === \"draft-07\") {\n        schema.maximum = ltOpts.value;\n        schema.exclusiveMaximum = true;\n      } else {\n        schema.exclusiveMaximum = ltOpts.value;\n      }\n    }\n\n    // multipleOf / modulo\n    const moduloOpts = getRuleOptions(this.rules, \"modulo\");\n    if (moduloOpts?.value !== undefined && typeof moduloOpts.value === \"number\") {\n      schema.multipleOf = moduloOpts.value;\n    }\n\n    // enum (from PrimitiveValidator.in / .enum)\n    const inOpts = getRuleOptions(this.rules, \"in\");\n    if (inOpts?.values && Array.isArray(inOpts.values)) {\n      schema.enum = inOpts.values;\n    }\n\n    if (this.isNullable) applyNullable(schema, target);\n\n    return schema;\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"number-validator.mjs","names":[],"sources":["../../../../../../../../packages/seal/src/validators/number-validator.ts"],"sourcesContent":["import {\n  absMutator,\n  ceilMutator,\n  floorMutator,\n  numericMutator,\n  roundMutator,\n  toFixedMutator,\n} from \"../mutators\";\nimport {\n  betweenNumbersRule,\n  evenRule,\n  greaterThanRule,\n  lengthRule,\n  lessThanRule,\n  maxLengthRule,\n  maxRule,\n  minLengthRule,\n  minRule,\n  moduloRule,\n  negativeRule,\n  numberRule,\n  oddRule,\n  positiveRule,\n} from \"../rules\";\nimport { PrimitiveValidator } from \"./primitive-validator\";\nimport { applyNullable, getRuleOptions } from \"../standard-schema/json-schema\";\nimport type { JsonSchemaResult, JsonSchemaTarget } from \"../standard-schema/json-schema\";\n\n/**\n * Number validator class - base for Int and Float validators\n */\nexport class NumberValidator extends PrimitiveValidator {\n  public constructor(errorMessage?: string) {\n    super();\n    this.blankIsMissing = true;\n    this.addMutableRule(numberRule, errorMessage);\n  }\n\n  /**\n   * Check if value is a number type\n   */\n  public matchesType(value: any): boolean {\n    return typeof value === \"number\" && !isNaN(value);\n  }\n\n  /**\n   * Value must be equal or higher than the given number or field\n   * Smart detection: number or field name\n   *\n   * @category Validation Rule\n   */\n  public min(min: number | string, errorMessage?: string) {\n    return this.addRule(minRule, errorMessage, { min, scope: \"global\" });\n  }\n\n  /**\n   * Value must be equal or less than the given number or field\n   * Smart detection: number or field name\n   *\n   * @category Validation Rule\n   */\n  public max(max: number | string, errorMessage?: string) {\n    return this.addRule(maxRule, errorMessage, { max, scope: \"global\" });\n  }\n\n  /**\n   * Value must be >= sibling field value\n   * @category Validation Rule\n   */\n  public minSibling(field: string, errorMessage?: string) {\n    return this.addRule(minRule, errorMessage, { min: field, scope: \"sibling\" });\n  }\n\n  /**\n   * Value must be <= sibling field value\n   * @category Validation Rule\n   */\n  public maxSibling(field: string, errorMessage?: string) {\n    return this.addRule(maxRule, errorMessage, { max: field, scope: \"sibling\" });\n  }\n\n  /**\n   * Value must be strictly greater than the given number or field (>)\n   * Smart detection: number or field name\n   *\n   * @category Validation Rule\n   */\n  public greaterThan(value: number | string, errorMessage?: string) {\n    return this.addRule(greaterThanRule, errorMessage, {\n      value,\n      scope: \"global\",\n    });\n  }\n\n  /**\n   * Value must be strictly less than the given number or field (<)\n   * Smart detection: number or field name\n   *\n   * @category Validation Rule\n   */\n  public lessThan(value: number | string, errorMessage?: string) {\n    return this.addRule(lessThanRule, errorMessage, {\n      value,\n      scope: \"global\",\n    });\n  }\n\n  /**\n   * Alias for greaterThan() - shorter syntax\n   * @category Validation Rule\n   */\n  public gt(value: number | string, errorMessage?: string) {\n    return this.greaterThan(value, errorMessage);\n  }\n\n  /**\n   * Alias for lessThan() - shorter syntax\n   * @category Validation Rule\n   */\n  public lt(value: number | string, errorMessage?: string) {\n    return this.lessThan(value, errorMessage);\n  }\n\n  /**\n   * Value must be > sibling field value\n   * @category Validation Rule\n   */\n  public greaterThanSibling(field: string, errorMessage?: string) {\n    return this.addRule(greaterThanRule, errorMessage, {\n      value: field,\n      scope: \"sibling\",\n    });\n  }\n\n  /**\n   * Alias for greaterThanSibling() - shorter syntax\n   * @category Validation Rule\n   */\n  public gtSibling(field: string, errorMessage?: string) {\n    return this.greaterThanSibling(field, errorMessage);\n  }\n\n  /**\n   * Value must be < sibling field value\n   * @category Validation Rule\n   */\n  public lessThanSibling(field: string, errorMessage?: string) {\n    return this.addRule(lessThanRule, errorMessage, {\n      value: field,\n      scope: \"sibling\",\n    });\n  }\n\n  /**\n   * Alias for lessThanSibling() - shorter syntax\n   * @category Validation Rule\n   */\n  public ltSibling(field: string, errorMessage?: string) {\n    return this.lessThanSibling(field, errorMessage);\n  }\n\n  /** Value must be a modulo of the given number */\n  public modulo(value: number, errorMessage?: string) {\n    return this.addRule(moduloRule, errorMessage, { value });\n  }\n\n  /**\n   * Alias for modulo() - Value must be divisible by the given number\n   */\n  public divisibleBy(value: number, errorMessage?: string) {\n    return this.modulo(value, errorMessage);\n  }\n\n  /**\n   * Alias for modulo() - Value must be a multiple of the given number\n   */\n  public multipleOf(value: number, errorMessage?: string) {\n    return this.modulo(value, errorMessage);\n  }\n\n  /**\n   * Alias for modulo() - Value must be a multiple of the given number\n   */\n  public modulusOf(value: number, errorMessage?: string) {\n    return this.modulo(value, errorMessage);\n  }\n\n  /** Accept only numbers higher than 0 */\n  public positive(errorMessage?: string) {\n    return this.addRule(positiveRule, errorMessage);\n  }\n\n  /** Accept only negative numbers */\n  public negative(errorMessage?: string) {\n    return this.addRule(negativeRule, errorMessage);\n  }\n\n  /** Accept only odd numbers */\n  public odd(errorMessage?: string) {\n    return this.addRule(oddRule, errorMessage);\n  }\n\n  /** Accept only even numbers */\n  public even(errorMessage?: string) {\n    return this.addRule(evenRule, errorMessage);\n  }\n\n  /**\n   * Accept only numbers between the given two numbers or fields (Inclusive)\n   * Smart detection: number or field name\n   *\n   * @category Validation Rule\n   */\n  public between(min: number | string, max: number | string, errorMessage?: string) {\n    return this.addRule(betweenNumbersRule, errorMessage, {\n      min,\n      max,\n      scope: \"global\",\n    });\n  }\n\n  /**\n   * Value must be between sibling field values\n   * @category Validation Rule\n   */\n  public betweenSibling(minField: string, maxField: string, errorMessage?: string) {\n    return this.addRule(betweenNumbersRule, errorMessage, {\n      min: minField,\n      max: maxField,\n      scope: \"sibling\",\n    });\n  }\n\n  // Enum and value membership methods are inherited from PrimitiveValidator.\n\n  /**\n   * Value (as a string) must be exactly this many characters.\n   * Useful for fixed-format numeric codes (e.g. 4-digit PIN).\n   */\n  public length(length: number, errorMessage?: string) {\n    return this.addRule(lengthRule, errorMessage, { length });\n  }\n\n  /** Value (as string representation) length must be ≥ min */\n  public minLength(length: number, errorMessage?: string) {\n    return this.addRule(minLengthRule, errorMessage, { minLength: length });\n  }\n\n  /** Value (as string representation) length must be ≤ max */\n  public maxLength(length: number, errorMessage?: string) {\n    return this.addRule(maxLengthRule, errorMessage, { maxLength: length });\n  }\n\n  // Mutators\n\n  /**\n   * Convert value to its absolute value\n   */\n  public abs() {\n    return this.addMutator(absMutator);\n  }\n\n  /**\n   * Round value up to the nearest integer\n   */\n  public ceil() {\n    return this.addMutator(ceilMutator);\n  }\n\n  /**\n   * Round value down to the nearest integer\n   */\n  public floor() {\n    return this.addMutator(floorMutator);\n  }\n\n  /**\n   * Round value to the nearest integer or specified decimals\n   */\n  public round(decimals = 0) {\n    return this.addMutator(roundMutator, { decimals });\n  }\n\n  /**\n   * Round to a fixed number of decimal places, keeping the value a **number**.\n   *\n   * `v.number().toFixed(2)` on `3.14159` yields `3.14`, not `\"3.14\"` — a number\n   * schema has to output a number, or its own type rule rejects the result.\n   * Format to a fixed-point *string* at the presentation edge instead.\n   *\n   * @example\n   * v.number().toFixed(2)   // 3.14159 → 3.14\n   */\n  public toFixed(decimals = 2) {\n    return this.addMutator(toFixedMutator, { decimals });\n  }\n\n  /**\n   * Opt in to coercion: a numeric-shaped string is converted to a number\n   * **before** the type rules run; any other value passes through unchanged\n   * so bad input still fails the type rule.\n   *\n   * Strictness is preserved — coercion only fixes the string *representation*,\n   * not the value's shape. `v.int().coerce()` turns `\"5\"` into `5` (valid) but\n   * `\"5.5\"` into `5.5`, which still fails the integer rule. Number validators\n   * do **not** coerce by default; this only takes effect when explicitly chained.\n   *\n   * The output type is unchanged (`Infer<>` keys off the validator class), so\n   * `v.int().coerce()` still infers `number`.\n   *\n   * @example\n   * v.int().coerce()      // \"5\" → 5 (valid); \"5.5\" → 5.5 (invalid); \"abc\" → invalid\n   * v.number().coerce()   // \"5.5\" → 5.5 (valid)\n   */\n  public coerce() {\n    return this.addMutator(numericMutator) as this & { isCoerced: true };\n  }\n\n  /**\n   * @inheritdoc\n   *\n   * Returns `{ type: \"number\" }` with numeric constraint keywords.\n   * IntValidator overrides `type` to `\"integer\"`.\n   *\n   * @note Sibling-scoped rules (minSibling, maxSibling, etc.) are not representable\n   * in JSON Schema and are silently omitted.\n   *\n   * @example\n   * ```ts\n   * v.number().min(0).max(100).toJsonSchema(\"draft-2020-12\")\n   * // → { type: \"number\", minimum: 0, maximum: 100 }\n   * ```\n   */\n  public override toJsonSchema(target: JsonSchemaTarget = \"draft-2020-12\"): JsonSchemaResult {\n    return this.buildNumberJsonSchema(\"number\", target);\n  }\n\n  /**\n   * Shared logic for number/integer JSON Schema generation.\n   * Called by NumberValidator.toJsonSchema() (→ type: \"number\")\n   * and IntValidator.toJsonSchema() (→ type: \"integer\").\n   */\n  protected buildNumberJsonSchema(\n    type: \"number\" | \"integer\",\n    target: JsonSchemaTarget,\n  ): JsonSchemaResult {\n    const schema: JsonSchemaResult = { type };\n\n    // minimum (inclusive)\n    const minOpts = getRuleOptions(this.rules, \"min\");\n    if (minOpts?.min !== undefined && typeof minOpts.min === \"number\") {\n      schema.minimum = minOpts.min;\n    }\n\n    // maximum (inclusive)\n    const maxOpts = getRuleOptions(this.rules, \"max\");\n    if (maxOpts?.max !== undefined && typeof maxOpts.max === \"number\") {\n      schema.maximum = maxOpts.max;\n    }\n\n    // between (inclusive range)\n    const betweenOpts = getRuleOptions(this.rules, \"betweenNumbers\");\n    if (betweenOpts) {\n      if (typeof betweenOpts.min === \"number\") schema.minimum = betweenOpts.min;\n      if (typeof betweenOpts.max === \"number\") schema.maximum = betweenOpts.max;\n    }\n\n    // greaterThan (>) → exclusiveMinimum\n    const gtOpts = getRuleOptions(this.rules, \"greaterThan\");\n    if (gtOpts?.value !== undefined && typeof gtOpts.value === \"number\") {\n      if (target === \"draft-07\") {\n        schema.minimum = gtOpts.value;\n        schema.exclusiveMinimum = true;\n      } else {\n        schema.exclusiveMinimum = gtOpts.value;\n      }\n    }\n\n    // lessThan (<) → exclusiveMaximum\n    const ltOpts = getRuleOptions(this.rules, \"lessThan\");\n    if (ltOpts?.value !== undefined && typeof ltOpts.value === \"number\") {\n      if (target === \"draft-07\") {\n        schema.maximum = ltOpts.value;\n        schema.exclusiveMaximum = true;\n      } else {\n        schema.exclusiveMaximum = ltOpts.value;\n      }\n    }\n\n    // multipleOf / modulo\n    const moduloOpts = getRuleOptions(this.rules, \"modulo\");\n    if (moduloOpts?.value !== undefined && typeof moduloOpts.value === \"number\") {\n      schema.multipleOf = moduloOpts.value;\n    }\n\n    // enum (from PrimitiveValidator.in / .enum)\n    const inOpts = getRuleOptions(this.rules, \"in\");\n    if (inOpts?.values && Array.isArray(inOpts.values)) {\n      schema.enum = inOpts.values;\n    }\n\n    if (this.isNullable) applyNullable(schema, target);\n\n    return schema;\n  }\n}\n"],"mappings":"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"}

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

@@ -1,10 +1,9 @@
 import { NumberValidator } from "./number-validator.mjs";
-
 //#region ../../packages/seal/src/validators/numeric-validator.d.ts
 /**
  * Numeric validator class - base for Int and Float validators either as number or string
  */
-declare class NumericValidator extends NumberValidator {
+export declare class NumericValidator extends NumberValidator {
   /**
    * Constructor
    */
@@ -15,5 +14,4 @@ declare class NumericValidator extends NumberValidator {
   matchesType(value: any): boolean;
 }
 //#endregion
-export { NumericValidator };
 //# sourceMappingURL=numeric-validator.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"numeric-validator.d.mts","names":[],"sources":["../../../../../../../../packages/seal/src/validators/numeric-validator.ts"],"mappings":";;;;;AAOA;cAAa,gBAAA,SAAyB,eAAe;;;;cAIhC,YAAA;EAAA;;;EAQZ,WAAA,CAAY,KAAA;AAAA"}
+{"version":3,"file":"numeric-validator.d.mts","names":[],"sources":["../../../../../../../../packages/seal/src/validators/numeric-validator.ts"],"mappings":";;;;;qBAOa,yBAAyB;;;;EAIpC,YAAmB;;;;EAQZ,YAAY"}

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

@@ -3,8 +3,8 @@ import { Schema } from "../types/schema-types.mjs";
 import { SchemaContext } from "../types/context-types.mjs";
 import { ValidationResult } from "../types/result-types.mjs";
 import { InferInputObjectShape, InferOutputObjectShape } from "../types/inference-types.mjs";
+import "../types/index.mjs";
 import { BaseValidator } from "./base-validator.mjs";
-
 //#region ../../packages/seal/src/validators/object-validator.d.ts
 /**
  * Object validator class with generic schema type for proper type inference.
@@ -22,7 +22,7 @@ import { BaseValidator } from "./base-validator.mjs";
  * recursive class-base evaluation that would otherwise occur when the
  * brand-aware widening tries to inspect the class type.
  */
-declare class ObjectValidator<TSchema extends Schema = Schema> extends BaseValidator<InferInputObjectShape<TSchema>, InferOutputObjectShape<TSchema>> {
+export declare class ObjectValidator<TSchema extends Schema = Schema> extends BaseValidator<InferInputObjectShape<TSchema>, InferOutputObjectShape<TSchema>> {
   schema: TSchema;
   protected shouldAllowUnknown: boolean;
   protected allowedKeys: string[];
@@ -249,5 +249,4 @@ declare class ObjectValidator<TSchema extends Schema = Schema> extends BaseValid
   toJsonSchema(target?: JsonSchemaTarget): JsonSchemaResult;
 }
 //#endregion
-export { ObjectValidator };
 //# sourceMappingURL=object-validator.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"object-validator.d.mts","names":[],"sources":["../../../../../../../../packages/seal/src/validators/object-validator.ts"],"mappings":";;;;;;;;;;;;AA6BA;;;;;;;;;;;;cAAa,eAAA,iBAAgC,MAAA,GAAS,MAAA,UAAgB,aAAA,CACpE,qBAAA,CAAsB,OAAA,GACtB,sBAAA,CAAuB,OAAA;EAOd,MAAA,EAAQ,OAAA;EAAA,UALP,kBAAA;EAAA,UACA,WAAA;EAAA,UACA,iBAAA;cAGD,MAAA,EAAQ,OAAA,EACf,YAAA;EAyK0B;;;EAhKrB,WAAA,CAAY,KAAA;EAkKU;EA7JtB,YAAA;EAyNqB;EA/MrB,KAAA,IAAS,IAAA;EA+MyD;EAxMlE,IAAA,CAAK,SAAA;EAwMwD;;;EAhM7D,YAAA,CAAa,KAAA;EAuOkB;;;;;;;;;;;;;EApNtB,KAAA,CAAM,IAAA;EApE8C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoI7D,MAAA,oBAA0B,MAAA,EAC/B,iBAAA,EAAmB,UAAA,GAAa,eAAA,CAAgB,UAAA,IAC/C,eAAA,CAAgB,OAAA,GAAU,UAAA;EA6ChB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAN,KAAA,gBAAqB,MAAA,EAC1B,SAAA,EAAW,eAAA,CAAgB,MAAA,IAC1B,eAAA,CAAgB,OAAA,GAAU,MAAA;EAmJc;;;;;;;;;;;;;;;;;;;;;;;AA+O+C;;;;;EAtUnF,IAAA,iBAAqB,OAAA,KAAY,IAAA,EAAM,CAAA,KAAM,eAAA,CAAgB,IAAA,CAAK,OAAA,EAAS,CAAA;;;;EAoB3E,OAAA,iBAAwB,OAAA,KAAY,IAAA,EAAM,CAAA;;;;EAmB1C,cAAA,iBAA+B,OAAA,KAAY,IAAA,EAAM,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgDjD,OAAA,iBAAwB,OAAA,KAAY,IAAA,EAAM,CAAA,KAAM,eAAA,CAAgB,IAAA,CAAK,OAAA,EAAS,CAAA;;EAkB9E,MAAA,CAAO,IAAA,OAAW,OAAA,EAAS,aAAA;;EAMrB,QAAA,CACX,IAAA,OACA,OAAA,GAAS,aAAA,GACR,OAAA,CAAQ,gBAAA;;;;;UA8JH,mBAAA;;;;UAOA,iBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+CQ,YAAA,CAAa,MAAA,GAAQ,gBAAA,GAAqC,gBAAA;AAAA"}
+{"version":3,"file":"object-validator.d.mts","names":[],"sources":["../../../../../../../../packages/seal/src/validators/object-validator.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;qBA6Ba,gBAAgB,gBAAgB,SAAS,gBAAgB,cACpE,sBAAsB,UACtB,uBAAuB;EAOd,QAAQ;YALP;YACA;YACA;EAEV,YACS,QAAQ,SACf;;;;EASK,YAAY;;EAKZ;;EAUA,SAAS;;EAOT,KAAK;;;;EAQL,aAAa;;;;;;;;;;;;;;EAmBJ,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgEf,OAAO,mBAAmB,QAC/B,mBAAmB,aAAa,gBAAgB,cAC/C,gBAAgB,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6CtB,MAAM,eAAe,QAC1B,WAAW,gBAAgB,UAC1B,gBAAgB,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6DtB,KAAK,gBAAgB,YAAY,MAAM,MAAM,gBAAgB,KAAK,SAAS;;;;EAoB3E,QAAQ,gBAAgB,YAAY,MAAM;;;;EAmB1C,eAAe,gBAAgB,YAAY,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgDjD,QAAQ,gBAAgB,YAAY,MAAM,MAAM,gBAAgB,KAAK,SAAS;;EAkB9E,OAAO,WAAW,SAAS;;EAMrB,SACX,WACA,UAAS,gBACR,QAAQ;;;;;UAiKH;;;;UAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+CQ,aAAa,SAAQ,mBAAqC"}

package/esm/validators/object-validator.mjs

@@ -172,6 +172,7 @@ var ObjectValidator = class ObjectValidator extends BaseValidator {
 		merged.shouldAllowUnknown = validator.shouldAllowUnknown;
 		merged.allowedKeys = [...merged.allowedKeys, ...validator.allowedKeys];
 		merged.rules.push(...validator.rules);
+		merged.refinements.push(...validator.refinements);
 		merged.mutators.push(...validator.mutators);
 		merged.dataTransformers.push(...validator.dataTransformers);
 		merged.attributesText = {
@@ -293,7 +294,7 @@ var ObjectValidator = class ObjectValidator extends BaseValidator {
 			});
 			this.setRuleAttributesList(rule);
 		}
-		const result = await super.validate(mutatedData, context);
+		const result = await this.validateRules(mutatedData, context);
 		if (result.isValid === false) return result;
 		if (mutatedData === void 0 || mutatedData === null) return result;
 		const errors = [];
@@ -344,14 +345,15 @@ var ObjectValidator = class ObjectValidator extends BaseValidator {
 		for (const key of Object.keys(this.schema)) if (key in validatedData) orderedData[key] = validatedData[key];
 		const cleanedData = removeUndefinedValues(orderedData);
 		const transformedData = await this.startTransformationPipeline(cleanedData, context);
-		return {
+		const output = this.shouldAllowUnknown === false ? transformedData : {
+			...transformedData,
+			...except(mutatedData, Object.keys(this.schema))
+		};
+		return this.refineResult({
 			isValid: true,
 			errors: [],
-			data: this.shouldAllowUnknown === false ? transformedData : {
-				...transformedData,
-				...except(mutatedData, Object.keys(this.schema))
-			}
-		};
+			data: output
+		}, context);
 	}
 	/**
 	* Check if a validator is a computed or managed field