@warlock.js/seal 5.30.0 → 5.32.0

package/esm/rules/common/type-rules.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"type-rules.d.mts","names":[],"sources":["../../../../../../../../../packages/seal/src/rules/common/type-rules.ts"],"mappings":";;;;;AAOA;cAAa,UAAA,EAAY,UASxB;;;AAAA;cAKY,UAAA,EAAY,UASxB;;;;cAKY,WAAA,EAAa,UASzB;AATD;;;AAAA,cAca,OAAA,EAAS,UASrB;AAdA;AAKD;;AALC,cAmBY,SAAA,EAAW,UASvB;;AAdA;AAKD;cAca,UAAA,EAAY,UASxB;;;AAdA;cAmBY,UAAA,EAAY,UAUxB;;;;cAKY,eAAA,EAAiB,UAU7B;AAzBD;;;AAAA,cA8Ba,SAAA,EAAW,UAUvB"}
+{"version":3,"file":"type-rules.d.mts","names":[],"sources":["../../../../../../../../../packages/seal/src/rules/common/type-rules.ts"],"mappings":";;;;;;qBAOa,YAAY;;;;qBAcZ,YAAY;;;;qBAcZ,aAAa;;;;qBAcb,SAAS;;;;qBAcT,WAAW;;;;qBAcX,YAAY;;;;qBAcZ,YAAY;;;;qBAeZ,iBAAiB;;;;qBAejB,WAAW"}

package/esm/rules/common/unknown-key.d.mts

@@ -1,14 +1,13 @@
 import { Schema } from "../../types/schema-types.mjs";
 import { SchemaRule } from "../../types/rule-types.mjs";
-
+import "../../types/index.mjs";
 //#region ../../packages/seal/src/rules/common/unknown-key.d.ts
 /**
  * Unknown key rule - validates that object doesn't have unknown keys
  */
-declare const unknownKeyRule: SchemaRule<{
+export declare const unknownKeyRule: SchemaRule<{
   schema: Schema;
   allowedKeys: string[];
 }>;
 //#endregion
-export { unknownKeyRule };
 //# sourceMappingURL=unknown-key.d.mts.map

package/esm/rules/common/unknown-key.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"unknown-key.d.mts","names":[],"sources":["../../../../../../../../../packages/seal/src/rules/common/unknown-key.ts"],"mappings":";;;;;;;cAMa,cAAA,EAAgB,UAAU;EACrC,MAAA,EAAQ,MAAA;EACR,WAAA;AAAA"}
+{"version":3,"file":"unknown-key.d.mts","names":[],"sources":["../../../../../../../../../packages/seal/src/rules/common/unknown-key.ts"],"mappings":";;;;;;;qBAMa,gBAAgB;EAC3B,QAAQ;EACR"}

package/esm/rules/conditional/forbidden-if-rules.d.mts

@@ -1,11 +1,11 @@
 import { SchemaRule } from "../../types/rule-types.mjs";
-
+import "../../types/index.mjs";
 //#region ../../packages/seal/src/rules/conditional/forbidden-if-rules.d.ts
 /**
  * Forbidden if rule - field is forbidden if another field equals a specific value
  * Supports both global and sibling scope
  */
-declare const forbiddenIfRule: SchemaRule<{
+export declare const forbiddenIfRule: SchemaRule<{
   field: string;
   value: any;
   scope?: "global" | "sibling";
@@ -14,7 +14,7 @@ declare const forbiddenIfRule: SchemaRule<{
  * Forbidden if not rule - field is forbidden if another field does NOT equal a specific value
  * Supports both global and sibling scope
  */
-declare const forbiddenIfNotRule: SchemaRule<{
+export declare const forbiddenIfNotRule: SchemaRule<{
   field: string;
   value: any;
   scope?: "global" | "sibling";
@@ -23,7 +23,7 @@ declare const forbiddenIfNotRule: SchemaRule<{
  * Forbidden if empty rule - field is forbidden if another field is empty
  * Supports both global and sibling scope
  */
-declare const forbiddenIfEmptyRule: SchemaRule<{
+export declare const forbiddenIfEmptyRule: SchemaRule<{
   field: string;
   scope?: "global" | "sibling";
 }>;
@@ -31,7 +31,7 @@ declare const forbiddenIfEmptyRule: SchemaRule<{
  * Forbidden if not empty rule - field is forbidden if another field is not empty
  * Supports both global and sibling scope
  */
-declare const forbiddenIfNotEmptyRule: SchemaRule<{
+export declare const forbiddenIfNotEmptyRule: SchemaRule<{
   field: string;
   scope?: "global" | "sibling";
 }>;
@@ -39,7 +39,7 @@ declare const forbiddenIfNotEmptyRule: SchemaRule<{
  * Forbidden if in rule - field is forbidden if another field's value is in the given array
  * Supports both global and sibling scope
  */
-declare const forbiddenIfInRule: SchemaRule<{
+export declare const forbiddenIfInRule: SchemaRule<{
   field: string;
   values: any[];
   scope?: "global" | "sibling";
@@ -48,11 +48,10 @@ declare const forbiddenIfInRule: SchemaRule<{
  * Forbidden if not in rule - field is forbidden if another field's value is NOT in the given array
  * Supports both global and sibling scope
  */
-declare const forbiddenIfNotInRule: SchemaRule<{
+export declare const forbiddenIfNotInRule: SchemaRule<{
   field: string;
   values: any[];
   scope?: "global" | "sibling";
 }>;
 //#endregion
-export { forbiddenIfEmptyRule, forbiddenIfInRule, forbiddenIfNotEmptyRule, forbiddenIfNotInRule, forbiddenIfNotRule, forbiddenIfRule };
 //# sourceMappingURL=forbidden-if-rules.d.mts.map

package/esm/rules/conditional/forbidden-if-rules.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"forbidden-if-rules.d.mts","names":[],"sources":["../../../../../../../../../packages/seal/src/rules/conditional/forbidden-if-rules.ts"],"mappings":";;;;;AAQA;;cAAa,eAAA,EAAiB,UAAU;EACtC,KAAA;EACA,KAAA;EACA,KAAA;AAAA;;;AAAK;AAyBP;cAAa,kBAAA,EAAoB,UAAU;EACzC,KAAA;EACA,KAAA;EACA,KAAA;AAAA;;;;AAAK;cAuBM,oBAAA,EAAsB,UAAU;EAC3C,KAAA;EACA,KAAA;AAAA;;;;;cAsBW,uBAAA,EAAyB,UAAU;EAC9C,KAAA;EACA,KAAA;AAAA;;;;;cAsBW,iBAAA,EAAmB,UAAU;EACxC,KAAA;EACA,MAAA;EACA,KAAA;AAAA;;;;;cAyBW,oBAAA,EAAsB,UAAU;EAC3C,KAAA;EACA,MAAA;EACA,KAAA;AAAA"}
+{"version":3,"file":"forbidden-if-rules.d.mts","names":[],"sources":["../../../../../../../../../packages/seal/src/rules/conditional/forbidden-if-rules.ts"],"mappings":";;;;;;;qBAQa,iBAAiB;EAC5B;EACA;EACA;;;;;;qBAyBW,oBAAoB;EAC/B;EACA;EACA;;;;;;qBAuBW,sBAAsB;EACjC;EACA;;;;;;qBAsBW,yBAAyB;EACpC;EACA;;;;;;qBAsBW,mBAAmB;EAC9B;EACA;EACA;;;;;;qBAyBW,sBAAsB;EACjC;EACA;EACA"}

package/esm/rules/conditional/index.d.mts

@@ -0,0 +1,11 @@
+import { requiredIfAllEmptyRule, requiredIfAllNotEmptyRule, requiredIfAnyEmptyRule, requiredIfAnyNotEmptyRule, requiredIfEmptyRule, requiredIfInRule, requiredIfNotEmptyRule, requiredIfNotInRule, requiredIfRule } from "./required-if-rules.mjs";
+import { requiredUnlessRule } from "./required-unless-rules.mjs";
+import { requiredWhenRule } from "./required-when-rule.mjs";
+import { requiredWithAllRule, requiredWithAnyRule, requiredWithRule } from "./required-with-rules.mjs";
+import { requiredWithoutAllRule, requiredWithoutAnyRule, requiredWithoutRule } from "./required-without-rules.mjs";
+import { presentIfEmptyRule, presentIfInRule, presentIfNotEmptyRule, presentIfNotInRule, presentIfRule } from "./present-if-rules.mjs";
+import { presentUnlessRule } from "./present-unless-rules.mjs";
+import { presentWithAllRule, presentWithAnyRule, presentWithRule } from "./present-with-rules.mjs";
+import { presentWithoutAllRule, presentWithoutAnyRule, presentWithoutRule } from "./present-without-rules.mjs";
+import { forbiddenIfEmptyRule, forbiddenIfInRule, forbiddenIfNotEmptyRule, forbiddenIfNotInRule, forbiddenIfNotRule, forbiddenIfRule } from "./forbidden-if-rules.mjs";
+export { forbiddenIfEmptyRule, forbiddenIfInRule, forbiddenIfNotEmptyRule, forbiddenIfNotInRule, forbiddenIfNotRule, forbiddenIfRule, presentIfEmptyRule, presentIfInRule, presentIfNotEmptyRule, presentIfNotInRule, presentIfRule, presentUnlessRule, presentWithAllRule, presentWithAnyRule, presentWithRule, presentWithoutAllRule, presentWithoutAnyRule, presentWithoutRule, requiredIfAllEmptyRule, requiredIfAllNotEmptyRule, requiredIfAnyEmptyRule, requiredIfAnyNotEmptyRule, requiredIfEmptyRule, requiredIfInRule, requiredIfNotEmptyRule, requiredIfNotInRule, requiredIfRule, requiredUnlessRule, requiredWhenRule, requiredWithAllRule, requiredWithAnyRule, requiredWithRule, requiredWithoutAllRule, requiredWithoutAnyRule, requiredWithoutRule };

package/esm/rules/conditional/index.mjs

@@ -9,4 +9,4 @@ import { presentWithAllRule, presentWithAnyRule, presentWithRule } from "./prese
 import { presentWithoutAllRule, presentWithoutAnyRule, presentWithoutRule } from "./present-without-rules.mjs";
 import { forbiddenIfEmptyRule, forbiddenIfInRule, forbiddenIfNotEmptyRule, forbiddenIfNotInRule, forbiddenIfNotRule, forbiddenIfRule } from "./forbidden-if-rules.mjs";
 
-export {  };
+export { forbiddenIfEmptyRule, forbiddenIfInRule, forbiddenIfNotEmptyRule, forbiddenIfNotInRule, forbiddenIfNotRule, forbiddenIfRule, presentIfEmptyRule, presentIfInRule, presentIfNotEmptyRule, presentIfNotInRule, presentIfRule, presentUnlessRule, presentWithAllRule, presentWithAnyRule, presentWithRule, presentWithoutAllRule, presentWithoutAnyRule, presentWithoutRule, requiredIfAllEmptyRule, requiredIfAllNotEmptyRule, requiredIfAnyEmptyRule, requiredIfAnyNotEmptyRule, requiredIfEmptyRule, requiredIfInRule, requiredIfNotEmptyRule, requiredIfNotInRule, requiredIfRule, requiredUnlessRule, requiredWhenRule, requiredWithAllRule, requiredWithAnyRule, requiredWithRule, requiredWithoutAllRule, requiredWithoutAnyRule, requiredWithoutRule };

package/esm/rules/conditional/present-if-rules.d.mts

@@ -1,11 +1,11 @@
 import { SchemaRule } from "../../types/rule-types.mjs";
-
+import "../../types/index.mjs";
 //#region ../../packages/seal/src/rules/conditional/present-if-rules.d.ts
 /**
  * Present if rule - field must be present if another field equals a specific value
  * Supports both global and sibling scope
  */
-declare const presentIfRule: SchemaRule<{
+export declare const presentIfRule: SchemaRule<{
   field: string;
   value: any;
   scope?: "global" | "sibling";
@@ -14,7 +14,7 @@ declare const presentIfRule: SchemaRule<{
  * Present if empty rule - field must be present if another field is empty
  * Supports both global and sibling scope
  */
-declare const presentIfEmptyRule: SchemaRule<{
+export declare const presentIfEmptyRule: SchemaRule<{
   field: string;
   scope?: "global" | "sibling";
 }>;
@@ -22,7 +22,7 @@ declare const presentIfEmptyRule: SchemaRule<{
  * Present if not empty rule - field must be present if another field is not empty
  * Supports both global and sibling scope
  */
-declare const presentIfNotEmptyRule: SchemaRule<{
+export declare const presentIfNotEmptyRule: SchemaRule<{
   field: string;
   scope?: "global" | "sibling";
 }>;
@@ -30,7 +30,7 @@ declare const presentIfNotEmptyRule: SchemaRule<{
  * Present if in rule - field must be present if another field's value is in the given array
  * Supports both global and sibling scope
  */
-declare const presentIfInRule: SchemaRule<{
+export declare const presentIfInRule: SchemaRule<{
   field: string;
   values: any[];
   scope?: "global" | "sibling";
@@ -39,11 +39,10 @@ declare const presentIfInRule: SchemaRule<{
  * Present if not in rule - field must be present if another field's value is NOT in the given array
  * Supports both global and sibling scope
  */
-declare const presentIfNotInRule: SchemaRule<{
+export declare const presentIfNotInRule: SchemaRule<{
   field: string;
   values: any[];
   scope?: "global" | "sibling";
 }>;
 //#endregion
-export { presentIfEmptyRule, presentIfInRule, presentIfNotEmptyRule, presentIfNotInRule, presentIfRule };
 //# sourceMappingURL=present-if-rules.d.mts.map

package/esm/rules/conditional/present-if-rules.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"present-if-rules.d.mts","names":[],"sources":["../../../../../../../../../packages/seal/src/rules/conditional/present-if-rules.ts"],"mappings":";;;;;AAQA;;cAAa,aAAA,EAAe,UAAU;EACpC,KAAA;EACA,KAAA;EACA,KAAA;AAAA;;;AAAK;AA0BP;cAAa,kBAAA,EAAoB,UAAU;EACzC,KAAA;EACA,KAAA;AAAA;;;;AAAK;cAuBM,qBAAA,EAAuB,UAAU;EAC5C,KAAA;EACA,KAAA;AAAA;;;;;cAuBW,eAAA,EAAiB,UAAU;EACtC,KAAA;EACA,MAAA;EACA,KAAA;AAAA;;;;;cAwBW,kBAAA,EAAoB,UAAU;EACzC,KAAA;EACA,MAAA;EACA,KAAA;AAAA"}
+{"version":3,"file":"present-if-rules.d.mts","names":[],"sources":["../../../../../../../../../packages/seal/src/rules/conditional/present-if-rules.ts"],"mappings":";;;;;;;qBAQa,eAAe;EAC1B;EACA;EACA;;;;;;qBA0BW,oBAAoB;EAC/B;EACA;;;;;;qBAuBW,uBAAuB;EAClC;EACA;;;;;;qBAuBW,iBAAiB;EAC5B;EACA;EACA;;;;;;qBAwBW,oBAAoB;EAC/B;EACA;EACA"}

package/esm/rules/conditional/present-unless-rules.d.mts

@@ -1,15 +1,14 @@
 import { SchemaRule } from "../../types/rule-types.mjs";
-
+import "../../types/index.mjs";
 //#region ../../packages/seal/src/rules/conditional/present-unless-rules.d.ts
 /**
  * Present unless rule - field must be present unless another field equals a specific value
  * Supports both global and sibling scope
  */
-declare const presentUnlessRule: SchemaRule<{
+export declare const presentUnlessRule: SchemaRule<{
   field: string;
   value: any;
   scope?: "global" | "sibling";
 }>;
 //#endregion
-export { presentUnlessRule };
 //# sourceMappingURL=present-unless-rules.d.mts.map

package/esm/rules/conditional/present-unless-rules.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"present-unless-rules.d.mts","names":[],"sources":["../../../../../../../../../packages/seal/src/rules/conditional/present-unless-rules.ts"],"mappings":";;;;;AAOA;;cAAa,iBAAA,EAAmB,UAAU;EACxC,KAAA;EACA,KAAA;EACA,KAAA;AAAA"}
+{"version":3,"file":"present-unless-rules.d.mts","names":[],"sources":["../../../../../../../../../packages/seal/src/rules/conditional/present-unless-rules.ts"],"mappings":";;;;;;;qBAOa,mBAAmB;EAC9B;EACA;EACA"}

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

@@ -1,11 +1,11 @@
 import { SchemaRule } from "../../types/rule-types.mjs";
-
+import "../../types/index.mjs";
 //#region ../../packages/seal/src/rules/conditional/present-with-rules.d.ts
 /**
  * Present with rule - field must be present if another field is present
  * Supports both global and sibling scope
  */
-declare const presentWithRule: SchemaRule<{
+export declare const presentWithRule: SchemaRule<{
   field: string;
   scope?: "global" | "sibling";
 }>;
@@ -13,7 +13,7 @@ declare const presentWithRule: SchemaRule<{
  * Present with all rule - field must be present if all specified fields are present
  * Supports both global and sibling scope
  */
-declare const presentWithAllRule: SchemaRule<{
+export declare const presentWithAllRule: SchemaRule<{
   fields: string[];
   scope?: "global" | "sibling";
 }>;
@@ -21,10 +21,9 @@ declare const presentWithAllRule: SchemaRule<{
  * Present with any rule - field must be present if any of the specified fields is present
  * Supports both global and sibling scope
  */
-declare const presentWithAnyRule: SchemaRule<{
+export declare const presentWithAnyRule: SchemaRule<{
   fields: string[];
   scope?: "global" | "sibling";
 }>;
 //#endregion
-export { presentWithAllRule, presentWithAnyRule, presentWithRule };
 //# sourceMappingURL=present-with-rules.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"present-with-rules.d.mts","names":[],"sources":["../../../../../../../../../packages/seal/src/rules/conditional/present-with-rules.ts"],"mappings":";;;;;AAQA;;cAAa,eAAA,EAAiB,UAAU;EACtC,KAAA;EACA,KAAA;AAAA;;;AAAK;AAwBP;cAAa,kBAAA,EAAoB,UAAU;EACzC,MAAA;EACA,KAAA;AAAA;;;;AAAK;cA+BM,kBAAA,EAAoB,UAAU;EACzC,MAAA;EACA,KAAA;AAAA"}
+{"version":3,"file":"present-with-rules.d.mts","names":[],"sources":["../../../../../../../../../packages/seal/src/rules/conditional/present-with-rules.ts"],"mappings":";;;;;;;qBAQa,iBAAiB;EAC5B;EACA;;;;;;qBAwBW,oBAAoB;EAC/B;EACA;;;;;;qBA+BW,oBAAoB;EAC/B;EACA"}

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

@@ -1,11 +1,11 @@
 import { SchemaRule } from "../../types/rule-types.mjs";
-
+import "../../types/index.mjs";
 //#region ../../packages/seal/src/rules/conditional/present-without-rules.d.ts
 /**
  * Present without rule - field must be present if another field is missing
  * Supports both global and sibling scope
  */
-declare const presentWithoutRule: SchemaRule<{
+export declare const presentWithoutRule: SchemaRule<{
   field: string;
   scope?: "global" | "sibling";
 }>;
@@ -13,7 +13,7 @@ declare const presentWithoutRule: SchemaRule<{
  * Present without all rule - field must be present if all specified fields are missing
  * Supports both global and sibling scope
  */
-declare const presentWithoutAllRule: SchemaRule<{
+export declare const presentWithoutAllRule: SchemaRule<{
   fields: string[];
   scope?: "global" | "sibling";
 }>;
@@ -21,10 +21,9 @@ declare const presentWithoutAllRule: SchemaRule<{
  * Present without any rule - field must be present if any of the specified fields is missing
  * Supports both global and sibling scope
  */
-declare const presentWithoutAnyRule: SchemaRule<{
+export declare const presentWithoutAnyRule: SchemaRule<{
   fields: string[];
   scope?: "global" | "sibling";
 }>;
 //#endregion
-export { presentWithoutAllRule, presentWithoutAnyRule, presentWithoutRule };
 //# sourceMappingURL=present-without-rules.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"present-without-rules.d.mts","names":[],"sources":["../../../../../../../../../packages/seal/src/rules/conditional/present-without-rules.ts"],"mappings":";;;;;AAQA;;cAAa,kBAAA,EAAoB,UAAU;EACzC,KAAA;EACA,KAAA;AAAA;;;AAAK;AAwBP;cAAa,qBAAA,EAAuB,UAAU;EAC5C,MAAA;EACA,KAAA;AAAA;;;;AAAK;cA+BM,qBAAA,EAAuB,UAAU;EAC5C,MAAA;EACA,KAAA;AAAA"}
+{"version":3,"file":"present-without-rules.d.mts","names":[],"sources":["../../../../../../../../../packages/seal/src/rules/conditional/present-without-rules.ts"],"mappings":";;;;;;;qBAQa,oBAAoB;EAC/B;EACA;;;;;;qBAwBW,uBAAuB;EAClC;EACA;;;;;;qBA+BW,uBAAuB;EAClC;EACA"}

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

@@ -1,11 +1,11 @@
 import { SchemaRule } from "../../types/rule-types.mjs";
-
+import "../../types/index.mjs";
 //#region ../../packages/seal/src/rules/conditional/required-if-rules.d.ts
 /**
  * Required if rule - field is required if another field equals a specific value
  * Supports both global and sibling scope
  */
-declare const requiredIfRule: SchemaRule<{
+export declare const requiredIfRule: SchemaRule<{
   field: string;
   value: any;
   scope?: "global" | "sibling";
@@ -14,7 +14,7 @@ declare const requiredIfRule: SchemaRule<{
  * Required if empty rule - field is required if another field is empty
  * Supports both global and sibling scope
  */
-declare const requiredIfEmptyRule: SchemaRule<{
+export declare const requiredIfEmptyRule: SchemaRule<{
   field: string;
   scope?: "global" | "sibling";
 }>;
@@ -22,7 +22,7 @@ declare const requiredIfEmptyRule: SchemaRule<{
  * Required if not empty rule - field is required if another field is not empty
  * Supports both global and sibling scope
  */
-declare const requiredIfNotEmptyRule: SchemaRule<{
+export declare const requiredIfNotEmptyRule: SchemaRule<{
   field: string;
   scope?: "global" | "sibling";
 }>;
@@ -30,7 +30,7 @@ declare const requiredIfNotEmptyRule: SchemaRule<{
  * Required if in rule - field is required if another field's value is in the given array
  * Supports both global and sibling scope
  */
-declare const requiredIfInRule: SchemaRule<{
+export declare const requiredIfInRule: SchemaRule<{
   field: string;
   values: any[];
   scope?: "global" | "sibling";
@@ -39,7 +39,7 @@ declare const requiredIfInRule: SchemaRule<{
  * Required if not in rule - field is required if another field's value is NOT in the given array
  * Supports both global and sibling scope
  */
-declare const requiredIfNotInRule: SchemaRule<{
+export declare const requiredIfNotInRule: SchemaRule<{
   field: string;
   values: any[];
   scope?: "global" | "sibling";
@@ -48,7 +48,7 @@ declare const requiredIfNotInRule: SchemaRule<{
  * Required if all empty rule - field is required if ALL specified fields are empty
  * Supports both global and sibling scope
  */
-declare const requiredIfAllEmptyRule: SchemaRule<{
+export declare const requiredIfAllEmptyRule: SchemaRule<{
   fields: string[];
   scope?: "global" | "sibling";
 }>;
@@ -56,7 +56,7 @@ declare const requiredIfAllEmptyRule: SchemaRule<{
  * Required if any empty rule - field is required if ANY of the specified fields is empty
  * Supports both global and sibling scope
  */
-declare const requiredIfAnyEmptyRule: SchemaRule<{
+export declare const requiredIfAnyEmptyRule: SchemaRule<{
   fields: string[];
   scope?: "global" | "sibling";
 }>;
@@ -64,7 +64,7 @@ declare const requiredIfAnyEmptyRule: SchemaRule<{
  * Required if all not empty rule - field is required if ALL specified fields are NOT empty
  * Supports both global and sibling scope
  */
-declare const requiredIfAllNotEmptyRule: SchemaRule<{
+export declare const requiredIfAllNotEmptyRule: SchemaRule<{
   fields: string[];
   scope?: "global" | "sibling";
 }>;
@@ -72,10 +72,9 @@ declare const requiredIfAllNotEmptyRule: SchemaRule<{
  * Required if any not empty rule - field is required if ANY of the specified fields is NOT empty
  * Supports both global and sibling scope
  */
-declare const requiredIfAnyNotEmptyRule: SchemaRule<{
+export declare const requiredIfAnyNotEmptyRule: SchemaRule<{
   fields: string[];
   scope?: "global" | "sibling";
 }>;
 //#endregion
-export { requiredIfAllEmptyRule, requiredIfAllNotEmptyRule, requiredIfAnyEmptyRule, requiredIfAnyNotEmptyRule, requiredIfEmptyRule, requiredIfInRule, requiredIfNotEmptyRule, requiredIfNotInRule, requiredIfRule };
 //# sourceMappingURL=required-if-rules.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"required-if-rules.d.mts","names":[],"sources":["../../../../../../../../../packages/seal/src/rules/conditional/required-if-rules.ts"],"mappings":";;;;;AASA;;cAAa,cAAA,EAAgB,UAAU;EACrC,KAAA;EACA,KAAA;EACA,KAAA;AAAA;;;AAAK;AAyBP;cAAa,mBAAA,EAAqB,UAAU;EAC1C,KAAA;EACA,KAAA;AAAA;;;;AAAK;cAwBM,sBAAA,EAAwB,UAAU;EAC7C,KAAA;EACA,KAAA;AAAA;;;;;cAwBW,gBAAA,EAAkB,UAAU;EACvC,KAAA;EACA,MAAA;EACA,KAAA;AAAA;;;;;cA0BW,mBAAA,EAAqB,UAAU;EAC1C,KAAA;EACA,MAAA;EACA,KAAA;AAAA;;;;;cAsCW,sBAAA,EAAwB,UAAU;EAC7C,MAAA;EACA,KAAA;AAAA;;;;;cA2BW,sBAAA,EAAwB,UAAU;EAC7C,MAAA;EACA,KAAA;AAAA;AAFF;;;;AAAA,cA6Ba,yBAAA,EAA2B,UAAU;EAChD,MAAA;EACA,KAAA;AAAA;AA7BK;AA2BP;;;AA3BO,cAwDM,yBAAA,EAA2B,UAAU;EAChD,MAAA;EACA,KAAA;AAAA"}
+{"version":3,"file":"required-if-rules.d.mts","names":[],"sources":["../../../../../../../../../packages/seal/src/rules/conditional/required-if-rules.ts"],"mappings":";;;;;;;qBASa,gBAAgB;EAC3B;EACA;EACA;;;;;;qBAyBW,qBAAqB;EAChC;EACA;;;;;;qBAwBW,wBAAwB;EACnC;EACA;;;;;;qBAwBW,kBAAkB;EAC7B;EACA;EACA;;;;;;qBA0BW,qBAAqB;EAChC;EACA;EACA;;;;;;qBAsCW,wBAAwB;EACnC;EACA;;;;;;qBA2BW,wBAAwB;EACnC;EACA;;;;;;qBA2BW,2BAA2B;EACtC;EACA;;;;;;qBA2BW,2BAA2B;EACtC;EACA"}

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

@@ -1,15 +1,14 @@
 import { SchemaRule } from "../../types/rule-types.mjs";
-
+import "../../types/index.mjs";
 //#region ../../packages/seal/src/rules/conditional/required-unless-rules.d.ts
 /**
  * Required unless rule - field is required unless another field equals a specific value
  * Supports both global and sibling scope
  */
-declare const requiredUnlessRule: SchemaRule<{
+export declare const requiredUnlessRule: SchemaRule<{
   field: string;
   value: any;
   scope?: "global" | "sibling";
 }>;
 //#endregion
-export { requiredUnlessRule };
 //# sourceMappingURL=required-unless-rules.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"required-unless-rules.d.mts","names":[],"sources":["../../../../../../../../../packages/seal/src/rules/conditional/required-unless-rules.ts"],"mappings":";;;;;AAQA;;cAAa,kBAAA,EAAoB,UAAU;EACzC,KAAA;EACA,KAAA;EACA,KAAA;AAAA"}
+{"version":3,"file":"required-unless-rules.d.mts","names":[],"sources":["../../../../../../../../../packages/seal/src/rules/conditional/required-unless-rules.ts"],"mappings":";;;;;;;qBAQa,oBAAoB;EAC/B;EACA;EACA"}

package/esm/rules/conditional/required-when-rule.d.mts

@@ -1,6 +1,6 @@
 import { SchemaRule } from "../../types/rule-types.mjs";
 import { SchemaContext } from "../../types/context-types.mjs";
-
+import "../../types/index.mjs";
 //#region ../../packages/seal/src/rules/conditional/required-when-rule.d.ts
 /**
  * Required when callback returns true.
@@ -15,9 +15,8 @@ import { SchemaContext } from "../../types/context-types.mjs";
  * })
  * ```
  */
-declare const requiredWhenRule: SchemaRule<{
+export declare const requiredWhenRule: SchemaRule<{
   callback: (context: SchemaContext) => boolean | Promise<boolean>;
 }>;
 //#endregion
-export { requiredWhenRule };
 //# sourceMappingURL=required-when-rule.d.mts.map

package/esm/rules/conditional/required-when-rule.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"required-when-rule.d.mts","names":[],"sources":["../../../../../../../../../packages/seal/src/rules/conditional/required-when-rule.ts"],"mappings":";;;;;;;AAiBA;;;;;;;;;;cAAa,gBAAA,EAAkB,UAAA;EAC7B,QAAA,GAAW,OAAA,EAAS,aAAA,eAA4B,OAAA;AAAA"}
+{"version":3,"file":"required-when-rule.d.mts","names":[],"sources":["../../../../../../../../../packages/seal/src/rules/conditional/required-when-rule.ts"],"mappings":";;;;;;;;;;;;;;;;;qBAiBa,kBAAkB;EAC7B,WAAW,SAAS,4BAA4B"}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

package/esm/rules/core/index.mjs

@@ -4,4 +4,4 @@ import { forbiddenRule } from "./forbidden.mjs";
 import { unionRule } from "./union.mjs";
 import { whenRule } from "./when.mjs";
 
-export {  };
+export { equalRule, forbiddenRule, presentRule, requiredRule, unionRule, whenRule };

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

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

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

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

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

@@ -1,13 +1,19 @@
 import { SchemaRule } from "../../types/rule-types.mjs";
+import "../../types/index.mjs";
 import { BaseValidator } from "../../validators/base-validator.mjs";
-
 //#region ../../packages/seal/src/rules/core/union.d.ts
 /**
- * Union rule - value must match at least one of the provided validators
+ * Union rule - value must match at least one of the provided validators.
+ *
+ * Every member whose type matches the value is tried, in order, until one
+ * passes. When none passes, the errors of the closest failed member (see
+ * `isCloser`) are reported at their own paths with the `union` type: its
+ * first error under `firstErrorOnly` (the default), all of them otherwise.
+ * A custom union error message replaces them with a single error, as does the
+ * default message when no member matches the value's type.
  */
-declare const unionRule: SchemaRule<{
+export declare const unionRule: SchemaRule<{
   validators: BaseValidator[];
 }>;
 //#endregion
-export { unionRule };
 //# sourceMappingURL=union.d.mts.map

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

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