@warlock.js/seal 5.31.0 → 5.32.0

package/esm/types/context-types.d.mts

@@ -1,8 +1,7 @@
 import { Schema } from "./schema-types.mjs";
 import { SchemaRule } from "./rule-types.mjs";
-
 //#region ../../packages/seal/src/types/context-types.d.ts
-type RuleTranslation = {
+export type RuleTranslation = {
   rule: SchemaRule;
   context: SchemaContext;
   attributes: {
@@ -13,7 +12,7 @@ type RuleTranslation = {
     [key: string]: any;
   };
 };
-type AttributeTranslation = {
+export type AttributeTranslation = {
   attribute: string;
   context: SchemaContext;
   rule: SchemaRule;
@@ -21,15 +20,24 @@ type AttributeTranslation = {
 /**
  * Validation context passed to validators and rules
  */
-type SchemaContext = {
-  /** All input values */allValues: any; /** Parent object if nested */
-  parent: any; /** Current value being validated */
-  value: any; /** Current key */
-  key: string; /** Full path to the current value */
-  path: string; /** Schema definition if object validator */
-  schema?: Schema; /** Additional context */
-  context?: Record<string, any>; /** Root context */
-  rootContext?: Record<string, any>; /** Translation function for error messages */
+export type SchemaContext = {
+  /** All input values */
+  allValues: any;
+  /** Parent object if nested */
+  parent: any;
+  /** Current value being validated */
+  value: any;
+  /** Current key */
+  key: string;
+  /** Full path to the current value */
+  path: string;
+  /** Schema definition if object validator */
+  schema?: Schema;
+  /** Additional context */
+  context?: Record<string, any>;
+  /** Root context */
+  rootContext?: Record<string, any>;
+  /** Translation function for error messages */
   translateRule: (ruleTranslation: RuleTranslation) => string;
   translateAttribute: (attributeTranslation: AttributeTranslation) => string;
   /**
@@ -37,12 +45,13 @@ type SchemaContext = {
    * this field's own `.default()`. The receiving validator reads it once and
    * clears it, so it never leaks into an array/tuple/record's item contexts.
    */
-  valueIsDefault?: boolean; /** Validation configurations */
+  valueIsDefault?: boolean;
+  /** Validation configurations */
   configurations?: {
-    firstErrorOnly?: boolean; /** Rendered as `:value` in error messages instead of the submitted input */
+    firstErrorOnly?: boolean;
+    /** Rendered as `:value` in error messages instead of the submitted input */
     redactValue?: string;
   };
 };
 //#endregion
-export { AttributeTranslation, RuleTranslation, SchemaContext };
 //# sourceMappingURL=context-types.d.mts.map

package/esm/types/context-types.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"context-types.d.mts","names":[],"sources":["../../../../../../../../packages/seal/src/types/context-types.ts"],"mappings":";;;;KAGY,eAAA;EACV,IAAA,EAAM,UAAA;EACN,OAAA,EAAS,aAAa;EACtB,UAAA;IACE,KAAA;IACA,IAAA;IACA,GAAA;IACA,KAAA;IAAA,CACC,GAAA;EAAA;AAAA;AAAA,KAIO,oBAAA;EACV,SAAA;EACA,OAAA,EAAS,aAAA;EACT,IAAA,EAAM,UAAU;AAAA;;AAPF;AAIhB;KASY,aAAA;yBAEV,SAAA,OAVA;EAYA,MAAA,OAXS;EAaT,KAAA,OAZM;EAcN,GAAA,UAdgB;EAgBhB,IAAA,UAVuB;EAYvB,MAAA,GAAS,MAAA,EAAA;EAET,OAAA,GAAU,MAAA,eAEI;EAAd,WAAA,GAAc,MAAA,eAG6B;EAD3C,aAAA,GAAgB,eAAA,EAAiB,eAAA;EACjC,kBAAA,GAAqB,oBAAA,EAAsB,oBAAA;EAjB3C;;;;;EAuBA,cAAA,YAbS;EAeT,cAAA;IACE,cAAA,YAZF;IAcE,WAAA;EAAA;AAAA"}
+{"version":3,"file":"context-types.d.mts","names":[],"sources":["../../../../../../../../packages/seal/src/types/context-types.ts"],"mappings":";;;YAGY;EACV,MAAM;EACN,SAAS;EACT;IACE;IACA;IACA;IACA;KACC;;;YAIO;EACV;EACA,SAAS;EACT,MAAM;;;;;YAMI;;EAEV;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA,SAAS;;EAET,UAAU;;EAEV,cAAc;;EAEd,gBAAgB,iBAAiB;EACjC,qBAAqB,sBAAsB;;;;;;EAM3C;;EAEA;IACE;;IAEA"}

package/esm/types/data-transformer-types.d.mts

@@ -1,12 +1,11 @@
 import { SchemaContext } from "./context-types.mjs";
-
 //#region ../../packages/seal/src/types/data-transformer-types.d.ts
 /**
  * Transformer callback signature
  * First param: the data to transform
  * Second param: object with options and context
  */
-type TransformerCallback = (data: any, params: {
+export type TransformerCallback = (data: any, params: {
   options: any;
   context: SchemaContext;
 }) => any | Promise<any>;
@@ -15,15 +14,14 @@ type TransformerCallback = (data: any, params: {
  * First param: the data to transform
  * Second param: validation context
  */
-type SimpleTransformerCallback = (data: any, context: SchemaContext) => any | Promise<any>;
+export type SimpleTransformerCallback = (data: any, context: SchemaContext) => any | Promise<any>;
 /**
  * Contextualized transformer - internal storage
  * Context is NOT stored, it's passed at runtime during validation
  */
-type ContextualizedTransformer = {
+export type ContextualizedTransformer = {
   transform: TransformerCallback;
   options: any;
 };
 //#endregion
-export { ContextualizedTransformer, SimpleTransformerCallback, TransformerCallback };
 //# sourceMappingURL=data-transformer-types.d.mts.map

package/esm/types/data-transformer-types.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"data-transformer-types.d.mts","names":[],"sources":["../../../../../../../../packages/seal/src/types/data-transformer-types.ts"],"mappings":";;;;;AAOA;;;KAAY,mBAAA,IACV,IAAA,OACA,MAAA;EACE,OAAA;EACA,OAAA,EAAS,aAAA;AAAA,YAEF,OAAO;;;;;AAAA;KAON,yBAAA,IAA6B,IAAA,OAAW,OAAA,EAAS,aAAA,WAAwB,OAAO;;;;;KAMhF,yBAAA;EACV,SAAA,EAAW,mBAAmB;EAC9B,OAAA;AAAA"}
+{"version":3,"file":"data-transformer-types.d.mts","names":[],"sources":["../../../../../../../../packages/seal/src/types/data-transformer-types.ts"],"mappings":";;;;;;;YAOY,uBACV,WACA;EACE;EACA,SAAS;YAEF;;;;;;YAOC,6BAA6B,WAAW,SAAS,wBAAwB;;;;;YAMzE;EACV,WAAW;EACX"}

package/esm/types/date-types.d.mts

@@ -2,11 +2,10 @@
 /**
  * Week day names for validation
  */
-type WeekDay = "sunday" | "monday" | "tuesday" | "wednesday" | "thursday" | "friday" | "saturday";
+export type WeekDay = "sunday" | "monday" | "tuesday" | "wednesday" | "thursday" | "friday" | "saturday";
 /**
  * Week day numbers mapping
  */
-declare const WEEK_DAYS: Record<WeekDay, number>;
+export declare const WEEK_DAYS: Record<WeekDay, number>;
 //#endregion
-export { WEEK_DAYS, WeekDay };
 //# sourceMappingURL=date-types.d.mts.map

package/esm/types/date-types.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"date-types.d.mts","names":[],"sources":["../../../../../../../../packages/seal/src/types/date-types.ts"],"mappings":";;AAGA;;KAAY,OAAA;;AAAO;AAYnB;cAAa,SAAA,EAAW,MAAM,CAAC,OAAA"}
+{"version":3,"file":"date-types.d.mts","names":[],"sources":["../../../../../../../../packages/seal/src/types/date-types.ts"],"mappings":";;;;YAGY;;;;qBAYC,WAAW,OAAO"}

package/esm/types/file.types.d.mts

@@ -1,8 +1,7 @@
 //#region ../../packages/seal/src/types/file.types.d.ts
-type FileSizeOption = {
+export type FileSizeOption = {
   size: number;
   unit: "B" | "KB" | "MB" | "GB";
 };
 //#endregion
-export { FileSizeOption };
 //# sourceMappingURL=file.types.d.mts.map

package/esm/types/file.types.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"file.types.d.mts","names":[],"sources":["../../../../../../../../packages/seal/src/types/file.types.ts"],"mappings":";KAAY,cAAA;EACV,IAAA;EACA,IAAI;AAAA"}
+{"version":3,"file":"file.types.d.mts","names":[],"sources":["../../../../../../../../packages/seal/src/types/file.types.ts"],"mappings":";YAAY;EACV;EACA"}

package/esm/types/index.d.mts

@@ -0,0 +1,11 @@
+import { Schema } from "./schema-types.mjs";
+import { ContextualSchemaRule, RuleResult, SchemaRule, SchemaRuleOptions, ValidationAttributesList } from "./rule-types.mjs";
+import { AttributeTranslation, RuleTranslation, SchemaContext } from "./context-types.mjs";
+import { TypedValidationResult, ValidationResult } from "./result-types.mjs";
+import { ContextualizedMutator, Mutator, MutatorContext } from "./mutator-types.mjs";
+import { WhenRuleOptions } from "./conditional-types.mjs";
+import { ContextualizedTransformer, SimpleTransformerCallback, TransformerCallback } from "./data-transformer-types.mjs";
+import { Infer, InferInput, InferInputObjectShape, InferObjectShape, InferOutput, InferOutputObjectShape, IsInputOptionalKey, IsOptionalKey, IsOutputOptionalKey, ValidatedOutput } from "./inference-types.mjs";
+import { WEEK_DAYS, WeekDay } from "./date-types.mjs";
+import { FileSizeOption } from "./file.types.mjs";
+export { AttributeTranslation, ContextualSchemaRule, ContextualizedMutator, ContextualizedTransformer, FileSizeOption, Infer, InferInput, InferInputObjectShape, InferObjectShape, InferOutput, InferOutputObjectShape, IsInputOptionalKey, IsOptionalKey, IsOutputOptionalKey, Mutator, MutatorContext, RuleResult, RuleTranslation, Schema, SchemaContext, SchemaRule, SchemaRuleOptions, SimpleTransformerCallback, TransformerCallback, TypedValidationResult, ValidatedOutput, ValidationAttributesList, ValidationResult, WEEK_DAYS, WeekDay, WhenRuleOptions };

package/esm/types/inference-types.d.mts

@@ -16,6 +16,7 @@ import { LiteralValidator } from "../validators/literal-validator.mjs";
 import { ManagedValidator } from "../validators/managed-validator.mjs";
 import { ScalarValidator } from "../validators/scalar-validator.mjs";
 import { StringValidator } from "../validators/string-validator.mjs";
+import "../validators/index.mjs";
 //#region ../../packages/seal/src/types/inference-types.d.ts
 /**
  * Two inference shapes describe the two halves of the validation pipeline:
@@ -91,7 +92,7 @@ type IsGuaranteed<V> = V extends {
  * guaranteed by `.default()` or `.catch()` — runtime always has a value
  * for guaranteed fields, so the output type marks them required.
  */
-type IsOutputOptionalKey<V> = V extends {
+export type IsOutputOptionalKey<V> = V extends {
   isOptional: true;
 } ? IsGuaranteed<V> extends true ? false : true : false;
 /**
@@ -100,7 +101,7 @@ type IsOutputOptionalKey<V> = V extends {
  * is present — any of those means the caller doesn't have to supply a value
  * (it'll be filled, defaulted, or rescued).
  */
-type IsInputOptionalKey<V> = V extends {
+export type IsInputOptionalKey<V> = V extends {
   isOptional: true;
 } | {
   hasDefault: true;
@@ -112,7 +113,7 @@ type IsInputOptionalKey<V> = V extends {
  * object type, so `Infer<>` reads (and compares) as a single literal instead
  * of an intersection of two mapped types.
  */
-type Flatten<T> = { [K in keyof T]: T[K] } & {};
+type Flatten<T> = { [K in keyof T]: T[K]; } & {};
 /**
  * Apply `| null` widening when the validator type carries `{ isNullable: true }`.
  *
@@ -131,20 +132,20 @@ type WithNullable<V, T> = V extends {
  * walker on the parent class's type parameter creates a recursive class-base
  * reference when combined with brand-checks.
  */
-type InferOutputObjectShape<S extends Schema> = Flatten<{ [K in keyof S as IsOutputOptionalKey<S[K]> extends true ? K : never]?: Infer.Output<S[K]> } & { [K in keyof S as IsOutputOptionalKey<S[K]> extends true ? never : K]: Infer.Output<S[K]> }>;
+export type InferOutputObjectShape<S extends Schema> = Flatten<{ [K in keyof S as IsOutputOptionalKey<S[K]> extends true ? K : never]?: Infer.Output<S[K]>; } & { [K in keyof S as IsOutputOptionalKey<S[K]> extends true ? never : K]: Infer.Output<S[K]>; }>;
 /**
  * Compute the inferred *input* object shape for a Schema. Mirror of
  * `InferOutputObjectShape` but uses `IsInputOptionalKey` — fields with
  * `.default()` or `.catch()` (or `.optional()`) are all marked optional in
  * the input shape.
  */
-type InferInputObjectShape<S extends Schema> = Flatten<{ [K in keyof S as IsInputOptionalKey<S[K]> extends true ? K : never]?: Infer.Input<S[K]> } & { [K in keyof S as IsInputOptionalKey<S[K]> extends true ? never : K]: Infer.Input<S[K]> }>;
+export type InferInputObjectShape<S extends Schema> = Flatten<{ [K in keyof S as IsInputOptionalKey<S[K]> extends true ? K : never]?: Infer.Input<S[K]>; } & { [K in keyof S as IsInputOptionalKey<S[K]> extends true ? never : K]: Infer.Input<S[K]>; }>;
 /**
  * Bare `Infer<T>` defaults to `Infer.Input<T>`. Use `Infer.Output<T>` when
  * typing validated data (Cascade `Model<>` params, validate() returns).
  */
-type Infer<T> = Infer.Input<T>;
-declare namespace Infer {
+export type Infer<T> = Infer.Input<T>;
+export declare namespace Infer {
   /**
    * Inferred *input* shape — what callers send before validation. Optional
    * keys whenever `.optional()`, `.default()`, or `.catch()` is present.
@@ -165,20 +166,20 @@ declare namespace Infer {
  * @deprecated Use `Infer.Input<T>` instead. Kept as an alias for one or two
  * minor versions to ease migration; removed thereafter.
  */
-type InferInput<T> = Infer.Input<T>;
+export type InferInput<T> = Infer.Input<T>;
 /**
  * @deprecated Use `Infer.Output<T>` instead. Kept as an alias for one or two
  * minor versions to ease migration; removed thereafter.
  */
-type InferOutput<T> = Infer.Output<T>;
+export type InferOutput<T> = Infer.Output<T>;
 /**
  * @deprecated Use `InferOutputObjectShape<S>` instead. Kept for back-compat.
  */
-type InferObjectShape<S extends Schema> = InferOutputObjectShape<S>;
+export type InferObjectShape<S extends Schema> = InferOutputObjectShape<S>;
 /**
  * @deprecated Use `IsOutputOptionalKey<V>` instead. Kept for back-compat.
  */
-type IsOptionalKey<V> = IsOutputOptionalKey<V>;
+export type IsOptionalKey<V> = IsOutputOptionalKey<V>;
 /**
  * The `data` type `validate(schema, input)` returns on success.
  *
@@ -189,7 +190,7 @@ type IsOptionalKey<V> = IsOutputOptionalKey<V>;
  * `validate()` was typed, so untyped call sites keep compiling. A
  * `v.record(...)` with a typed value keeps its `Record<string, …>` output.
  */
-type ValidatedOutput<T> = [Infer.Output<T>] extends [infer O] ? unknown extends O ? any : O extends object ? string extends keyof O ? unknown extends O[keyof O] ? any : O : O : O : never;
+export type ValidatedOutput<T> = [Infer.Output<T>] extends [infer O] ? unknown extends O ? any : O extends object ? string extends keyof O ? unknown extends O[keyof O] ? any : O : O : O : never;
 //#endregion
-export { Infer, InferInput, InferInputObjectShape, InferObjectShape, InferOutput, InferOutputObjectShape, IsInputOptionalKey, IsOptionalKey, IsOutputOptionalKey, ValidatedOutput };
+export {};
 //# sourceMappingURL=inference-types.d.mts.map

package/esm/types/inference-types.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"inference-types.d.mts","names":[],"sources":["../../../../../../../../packages/seal/src/types/inference-types.ts"],"mappings":"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"}
+{"version":3,"file":"inference-types.d.mts","names":[],"sources":["../../../../../../../../packages/seal/src/types/inference-types.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAqFK,aAAa,KAAK;EAAY;WAE/B;EAAY;;;;;;;;YAUJ,oBAAoB,KAAK;EAAY;IAC7C,aAAa;;;;;;;YAWL,mBAAmB,KAAK;EAC9B;;EACA;;EACA;;;;;;;KASD,QAAQ,QAAQ,WAAW,IAAI,EAAE;;;;;;;;KASjC,aAAa,GAAG,KAAK;EAAY;IAAqB,WAAW;;;;;;;;;YAU1D,uBAAuB,UAAU,UAAU,WAElD,WAAW,KAAK,oBAAoB,EAAE,mBAAmB,aAAa,MAAM,OAAO,EAAE,YAErF,WAAW,KAAK,oBAAoB,EAAE,2BAA2B,IAAI,MAAM,OAAO,EAAE;;;;;;;YAU7E,sBAAsB,UAAU,UAAU,WAEjD,WAAW,KAAK,mBAAmB,EAAE,mBAAmB,aAAa,MAAM,MAAM,EAAE,YAEnF,WAAW,KAAK,mBAAmB,EAAE,2BAA2B,IAAI,MAAM,MAAM,EAAE;;;;;YAQ3E,MAAM,KAAK,MAAM,MAAM;yBAGlB;;;;;OAKH,MAAM,KAChB,UAAU,oBAAoB,KAC1B,MAAM,KACN,UAAU,uCAAuC,YAC/C,iBAAiB,oBAAoB,KACnC,UAAU,gBACR,aAAa,GAAG,MAAM,sBAG1B,UAAU,sBAAsB,KAC9B,aAAa,GAAG,sBAAsB,MACtC,UAAU,iBACR;IAAY,iBAAiB,UAAU;MACrC,aAAa,GAAG,MAAM,MAAM,eAE9B,UAAU,uBAAuB,KAC/B,aAAa,GAAG,aAChB,UAAU,0BAA0B,KAClC,aAAa,GAAG,KAChB,UAAU,wBAAwB,KAChC,IACA,UAAU,uBAAuB,KAC/B,IACA,UAAU,uBAAuB,UAC/B,aAAa,GAAG,KAChB,UAAU,kBACR,aAAa,aACb,UAAU,eACR,aAAa,aACb,UAAU,iBACR,aAAa,aACb,UAAU,mBACR,aAAa,cACb,UAAU,gBACR,aAAa,GAAG,QAChB,UAAU,kBACR,aAAa,gCACb,UAAU;;;;;;OAShC,OAAO,KACjB,UAAU,oBAAoB,KAC1B,OAAO,KACP,UAAU,uCAAuC,YAC/C,iBAAiB,oBAAoB,KACnC,UAAU,gBACR,aAAa,GAAG,OAAO,sBAG3B,UAAU,sBAAsB,KAC9B,aAAa,GAAG,uBAAuB,MACvC,UAAU,iBACR;IAAY,iBAAiB,UAAU;MACrC,aAAa,GAAG,MAAM,OAAO,eAE/B,UAAU,uBAAuB,KAC/B,aAAa,GAAG,aAChB,UAAU,0BAA0B,KAClC,aAAa,GAAG,KAChB,UAAU,wBAAwB,KAChC,IACA,UAAU,uBAAuB,KAC/B,IAMA,UAAU,mBACR,aAAa,GAAG,iBAAiB,YAAY,MAC7C,UAAU,kBACR,aAAa,aACb,UAAU,eACR,aAAa,aACb,UAAU,iBACR,aAAa,aACb,UAAU,mBACR,aAAa,cACb,UAAU,gBACR,aAAa,GAAG,QAChB,UAAU,kBACR,aAAa,gCACb,UAAU;;;;;;YASlC,WAAW,KAAK,MAAM,MAAM;;;;;YAM5B,YAAY,KAAK,MAAM,OAAO;;;;YAK9B,iBAAiB,UAAU,UAAU,uBAAuB;;;;YAK5D,cAAc,KAAK,oBAAoB;;;;;;;;;;;YAYvC,gBAAgB,MAAM,MAAM,OAAO,mBAAmB,qBAC9C,UAEd,wCACuB,oBACH,QAAQ,WAEtB,IACF,IACF"}

package/esm/types/mutator-types.d.mts

@@ -1,27 +1,29 @@
 import { SchemaContext } from "./context-types.mjs";
-
 //#region ../../packages/seal/src/types/mutator-types.d.ts
 /**
  * Mutator context
  */
-type MutatorContext<Options = any> = {
-  /** Mutator options */options: Options; /** Global validation context */
+export type MutatorContext<Options = any> = {
+  /** Mutator options */
+  options: Options;
+  /** Global validation context */
   ctx: SchemaContext;
 };
 /**
  * Mutator function - transforms data before validation
  */
-type Mutator<Options = any> = (data: any, context?: MutatorContext<Options>) => Promise<any>;
+export type Mutator<Options = any> = (data: any, context?: MutatorContext<Options>) => Promise<any>;
 /**
  * Contextualized mutator - mutator with runtime context
  */
-type ContextualizedMutator<Options = any> = {
-  /** Mutation function */mutate: Mutator<Options>; /** Mutator context */
+export type ContextualizedMutator<Options = any> = {
+  /** Mutation function */
+  mutate: Mutator<Options>;
+  /** Mutator context */
   context: {
     options: Options;
     ctx: SchemaContext;
   };
 };
 //#endregion
-export { ContextualizedMutator, Mutator, MutatorContext };
 //# sourceMappingURL=mutator-types.d.mts.map

package/esm/types/mutator-types.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"mutator-types.d.mts","names":[],"sources":["../../../../../../../../packages/seal/src/types/mutator-types.ts"],"mappings":";;;;;AAKA;KAAY,cAAA;EAAc,sBAExB,OAAA,EAAS,OAAA,EAFgB;EAIzB,GAAA,EAAK,aAAa;AAAA;;;;KAMR,OAAA,mBAA0B,IAAA,OAAW,OAAA,GAAU,cAAA,CAAe,OAAA,MAAa,OAAA;AAAvF;;;AAAA,KAKY,qBAAA;EAL+C,wBAOzD,MAAA,EAAQ,OAAA,CAAQ,OAAA,GAP4E;EAS5F,OAAA;IACE,OAAA,EAAS,OAAA;IACT,GAAA,EAAK,aAAA;EAAA;AAAA"}
+{"version":3,"file":"mutator-types.d.mts","names":[],"sources":["../../../../../../../../packages/seal/src/types/mutator-types.ts"],"mappings":";;;;;YAKY,eAAe;;EAEzB,SAAS;;EAET,KAAK;;;;;YAMK,QAAQ,kBAAkB,WAAW,UAAU,eAAe,aAAa;;;;YAK3E,sBAAsB;;EAEhC,QAAQ,QAAQ;;EAEhB;IACE,SAAS;IACT,KAAK"}

package/esm/types/result-types.d.mts

@@ -2,12 +2,18 @@
 /**
  * Validation result
  */
-type ValidationResult = {
-  /** Whether validation passed */isValid: boolean; /** Validated and potentially mutated data */
-  data: any; /** List of validation errors */
+export type ValidationResult = {
+  /** Whether validation passed */
+  isValid: boolean;
+  /** Validated and potentially mutated data */
+  data: any;
+  /** List of validation errors */
   errors: {
-    /** Rule type that failed */type: string; /** Error message */
-    error: string; /** Input field name */
+    /** Rule type that failed */
+    type: string;
+    /** Error message */
+    error: string;
+    /** Input field name */
     input: string;
   }[];
 };
@@ -26,7 +32,7 @@ type ValidationResult = {
  * result.data; // Infer.Output<typeof schema>
  * ```
  */
-type TypedValidationResult<TData> = {
+export type TypedValidationResult<TData> = {
   isValid: true;
   data: TData;
   errors: ValidationResult["errors"];
@@ -36,5 +42,4 @@ type TypedValidationResult<TData> = {
   errors: ValidationResult["errors"];
 };
 //#endregion
-export { TypedValidationResult, ValidationResult };
 //# sourceMappingURL=result-types.d.mts.map

package/esm/types/result-types.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"result-types.d.mts","names":[],"sources":["../../../../../../../../packages/seal/src/types/result-types.ts"],"mappings":";;AAGA;;KAAY,gBAAA;EAAgB,gCAE1B,OAAA,WAEA;EAAA,IAAA,OAIE;EAFF,MAAA;IAME,4BAJA,IAAA,UAIK;IAFL,KAAA,UAqB6B;IAnB7B,KAAA;EAAA;AAAA;;;;;;;;;;;;;;;AAqB2D;KAFnD,qBAAA;EACN,OAAA;EAAe,IAAA,EAAM,KAAA;EAAO,MAAA,EAAQ,gBAAA;AAAA;EACpC,OAAA;EAAgB,IAAA;EAAiB,MAAA,EAAQ,gBAAA;AAAA"}
+{"version":3,"file":"result-types.d.mts","names":[],"sources":["../../../../../../../../packages/seal/src/types/result-types.ts"],"mappings":";;;;YAGY;;EAEV;;EAEA;;EAEA;;IAEE;;IAEA;;IAEA;;;;;;;;;;;;;;;;;;YAmBQ,sBAAsB;EAC5B;EAAe,MAAM;EAAO,QAAQ;;EACpC;EAAgB;EAAiB,QAAQ"}

package/esm/types/rule-types.d.mts

@@ -1,10 +1,9 @@
 import { SchemaContext } from "./context-types.mjs";
-
 //#region ../../packages/seal/src/types/rule-types.d.ts
 /**
  * Rule validation result
  */
-type RuleResult = {
+export type RuleResult = {
   isValid: false;
   error: string;
   input: string;
@@ -18,31 +17,39 @@ type RuleResult = {
     path: string;
   }>;
 } | {
-  isValid: true; /** Replace the validated value, including an explicit undefined output. */
+  isValid: true;
+  /** Replace the validated value, including an explicit undefined output. */
   data?: unknown;
 };
 type AttributeValue = string | number;
-type ValidationAttributesList = Record<string, AttributeValue | Record<string, AttributeValue>>;
+export type ValidationAttributesList = Record<string, AttributeValue | Record<string, AttributeValue>>;
 /**
  * Rule options - generic options passed to rules
  */
-type SchemaRuleOptions<T = any> = Record<string, T>;
+export type SchemaRuleOptions<T = any> = Record<string, T>;
 /**
  * Schema rule definition
  */
-type SchemaRule<Options extends SchemaRuleOptions = SchemaRuleOptions> = {
-  /** Rule name */name: string; /** Rule description */
-  description?: string; /** Whether the rule requires a non-undefined value */
-  requiresValue?: boolean; /** Validation function */
-  validate: (this: ContextualSchemaRule<Options>, value: any, context: SchemaContext) => Promise<RuleResult>; /** Default error message */
-  defaultErrorMessage?: string; /** Error message */
-  errorMessage?: string; /** Sort order for rule execution */
+export type SchemaRule<Options extends SchemaRuleOptions = SchemaRuleOptions> = {
+  /** Rule name */
+  name: string;
+  /** Rule description */
+  description?: string;
+  /** Whether the rule requires a non-undefined value */
+  requiresValue?: boolean;
+  /** Validation function */
+  validate: (this: ContextualSchemaRule<Options>, value: any, context: SchemaContext) => Promise<RuleResult>;
+  /** Default error message */
+  defaultErrorMessage?: string;
+  /** Error message */
+  errorMessage?: string;
+  /** Sort order for rule execution */
   sortOrder?: number;
 };
 /**
  * Contextualized schema rule - rule with runtime context
  */
-type ContextualSchemaRule<Options extends SchemaRuleOptions = SchemaRuleOptions> = SchemaRule & {
+export type ContextualSchemaRule<Options extends SchemaRuleOptions = SchemaRuleOptions> = SchemaRule & {
   /**
    * The context object is used to pass additional information to the rule
    * This will be always overridden when the rule is injected into a validator
@@ -51,11 +58,13 @@ type ContextualSchemaRule<Options extends SchemaRuleOptions = SchemaRuleOptions>
     errorMessage?: string;
     options: Options;
     attributesList: ValidationAttributesList;
-    translatedAttributes: Record<string, string>; /** Raw placeholder values — substituted as-is (enums, numbers, computed strings) */
-    translationParams: Record<string, any>; /** Field-key placeholder values — passed through the attribute translator before substitution */
+    translatedAttributes: Record<string, string>;
+    /** Raw placeholder values — substituted as-is (enums, numbers, computed strings) */
+    translationParams: Record<string, any>;
+    /** Field-key placeholder values — passed through the attribute translator before substitution */
     translatableParams: Record<string, string>;
   };
 };
 //#endregion
-export { ContextualSchemaRule, RuleResult, SchemaRule, SchemaRuleOptions, ValidationAttributesList };
+export {};
 //# sourceMappingURL=rule-types.d.mts.map

package/esm/types/rule-types.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"rule-types.d.mts","names":[],"sources":["../../../../../../../../packages/seal/src/types/rule-types.ts"],"mappings":";;;;;AAKA;KAAY,UAAA;EAEN,OAAA;EACA,KAAA;EACA,KAAA;EACA,IAAA;EADA;;;;EAMA,MAAA,GAAS,KAAK;IAAG,KAAA;IAAe,IAAA;EAAA;AAAA;EAGhC,OAAA,QAKD;EAHC,IAAA;AAAA;AAAA,KAGD,cAAA;AAAA,KAEO,wBAAA,GAA2B,MAAA,SAErC,cAAA,GAAiB,MAAA,SAAe,cAAA;AAFlC;;;AAAA,KAQY,iBAAA,YAA6B,MAAM,SAAS,CAAA;;;;KAK5C,UAAA,iBAA2B,iBAAA,GAAoB,iBAAA;EAbd,gBAe3C,IAAA,UAbA;EAeA,WAAA,WAfgC;EAiBhC,aAAA,YAjB8C;EAmB9C,QAAA,GACE,IAAA,EAAM,oBAAA,CAAqB,OAAA,GAC3B,KAAA,OACA,OAAA,EAAS,aAAA,KACN,OAAA,CAAQ,UAAA,GAjBc;EAmB3B,mBAAA,WAnB6C;EAqB7C,YAAA,WArBuC;EAuBvC,SAAA;AAAA;AAvBuD;AAKzD;;AALyD,KA6B7C,oBAAA,iBAAqC,iBAAA,GAAoB,iBAAA,IACnE,UAAA;EAzBqC;;;;EA8BnC,OAAA;IACE,YAAA;IACA,OAAA,EAAS,OAAA;IACT,cAAA,EAAgB,wBAAA;IAChB,oBAAA,EAAsB,MAAA,kBAlCL;IAoCjB,iBAAA,EAAmB,MAAA,eApCkC;IAsCrD,kBAAA,EAAoB,MAAA;EAAA;AAAA"}
+{"version":3,"file":"rule-types.d.mts","names":[],"sources":["../../../../../../../../packages/seal/src/types/rule-types.ts"],"mappings":";;;;;YAKY;EAEN;EACA;EACA;EACA;;;;;EAKA,SAAS;IAAQ;IAAe;;;EAGhC;;EAEA;;KAGD;YAEO,2BAA2B,eAErC,iBAAiB,eAAe;;;;YAMtB,kBAAkB,WAAW,eAAe;;;;YAK5C,WAAW,gBAAgB,oBAAoB;;EAEzD;;EAEA;;EAEA;;EAEA,WACE,MAAM,qBAAqB,UAC3B,YACA,SAAS,kBACN,QAAQ;;EAEb;;EAEA;;EAEA;;;;;YAMU,qBAAqB,gBAAgB,oBAAoB,qBACnE;;;;;EAKE;IACE;IACA,SAAS;IACT,gBAAgB;IAChB,sBAAsB;;IAEtB,mBAAmB;;IAEnB,oBAAoB"}

package/esm/types/schema-types.d.mts

@@ -1,10 +1,8 @@
 import { BaseValidator } from "../validators/base-validator.mjs";
-
 //#region ../../packages/seal/src/types/schema-types.d.ts
 /**
  * Schema definition - a record of validators
  */
-type Schema = Record<string, BaseValidator>;
+export type Schema = Record<string, BaseValidator>;
 //#endregion
-export { Schema };
 //# sourceMappingURL=schema-types.d.mts.map

package/esm/types/schema-types.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"schema-types.d.mts","names":[],"sources":["../../../../../../../../packages/seal/src/types/schema-types.ts"],"mappings":";;;;;AAKA;KAAY,MAAA,GAAS,MAAM,SAAS,aAAA"}
+{"version":3,"file":"schema-types.d.mts","names":[],"sources":["../../../../../../../../packages/seal/src/types/schema-types.ts"],"mappings":";;;;;YAKY,SAAS,eAAe"}

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

@@ -1,11 +1,10 @@
 import { JsonSchemaResult, JsonSchemaTarget } from "../standard-schema/json-schema.mjs";
 import { BaseValidator } from "./base-validator.mjs";
-
 //#region ../../packages/seal/src/validators/any-validator.d.ts
 /**
  * Any validator - accepts any value
  */
-declare class AnyValidator extends BaseValidator {
+export declare class AnyValidator extends BaseValidator {
   /**
    * Any validator means any value, so we disable the default required requirement.
    */
@@ -29,5 +28,4 @@ declare class AnyValidator extends BaseValidator {
   toJsonSchema(target?: JsonSchemaTarget): JsonSchemaResult;
 }
 //#endregion
-export { AnyValidator };
 //# sourceMappingURL=any-validator.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"any-validator.d.mts","names":[],"sources":["../../../../../../../../packages/seal/src/validators/any-validator.ts"],"mappings":";;;;;;AAOA;cAAa,YAAA,SAAqB,aAAA;;;;EAIhB,YAAA;EAJ6B;;;EAS7B,UAAA;EAAA;;;;;;AAc0E;;;;;;EAA1E,YAAA,CAAa,MAAA,GAAQ,gBAAA,GAAqC,gBAAA;AAAA"}
+{"version":3,"file":"any-validator.d.mts","names":[],"sources":["../../../../../../../../packages/seal/src/validators/any-validator.ts"],"mappings":";;;;;;qBAOa,qBAAqB;;;;EAIhB;;;;EAKA;;;;;;;;;;;;;EAcA,aAAa,SAAQ,mBAAqC"}

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

@@ -1,13 +1,13 @@
 import { JsonSchemaResult, JsonSchemaTarget } from "../standard-schema/json-schema.mjs";
 import { SchemaContext } from "../types/context-types.mjs";
 import { ValidationResult } from "../types/result-types.mjs";
+import "../types/index.mjs";
 import { BaseValidator } from "./base-validator.mjs";
-
 //#region ../../packages/seal/src/validators/array-validator.d.ts
 /**
  * Array validator class
  */
-declare class ArrayValidator extends BaseValidator {
+export declare class ArrayValidator extends BaseValidator {
   validator: BaseValidator;
   constructor(validator: BaseValidator, errorMessage?: string);
   /**
@@ -82,5 +82,4 @@ declare class ArrayValidator extends BaseValidator {
   toJsonSchema(target?: JsonSchemaTarget): JsonSchemaResult;
 }
 //#endregion
-export { ArrayValidator };
 //# sourceMappingURL=array-validator.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"array-validator.d.mts","names":[],"sources":["../../../../../../../../packages/seal/src/validators/array-validator.ts"],"mappings":";;;;;;;;;cAmBa,cAAA,SAAuB,aAAA;EAEzB,SAAA,EAAW,aAAA;cAAX,SAAA,EAAW,aAAA,EAClB,YAAA;EADkB;;;EAWb,WAAA,CAAY,KAAA;EA8G+C;;;EAvGlD,KAAA;EApBkB;EA6B3B,IAAA;EA7BwC;EAkCxC,OAAA;EAhCE;EAqCF,UAAA;;EAKA,IAAA,CAAK,SAAA,mBAAmC,GAAA;EA1CtC;EA+CF,GAAA,CAAI,GAAA,UAAa,YAAA;EApCjB;EAyCA,SAAA,CAAU,MAAA,UAAgB,YAAA;EAlCjB;EAuCT,GAAA,CAAI,GAAA,UAAa,YAAA;EAzBjB;EA8BA,SAAA,CAAU,MAAA,UAAgB,YAAA;EApB1B;EAyBA,MAAA,CAAO,MAAA,UAAgB,YAAA;EAzBiB;;;;;;;;;;;;;;EA2CxC,OAAA,CAAQ,GAAA,UAAa,GAAA,UAAa,YAAA;EAlBX;;;EA4BvB,aAAA,CAAc,GAAA,UAAa,GAAA,UAAa,YAAA;EAVN;EAelC,MAAA,CAAO,YAAA;EALO;EAUd,MAAA,CAAO,SAAA,mBAAmC,YAAA;EAVF;EAexC,MAAA,CAAO,IAAA,OAAW,OAAA,EAAS,aAAA;EAVpB;;;;;;EAqBD,QAAA,CAAS,IAAA,OAAW,OAAA,EAAS,aAAA,GAAgB,OAAA,CAAQ,gBAAA;EAXzC;;;;;;;;;;;EA2ET,YAAA,CAAa,MAAA,GAAQ,gBAAA,GAAqC,gBAAA;AAAA"}
+{"version":3,"file":"array-validator.d.mts","names":[],"sources":["../../../../../../../../packages/seal/src/validators/array-validator.ts"],"mappings":";;;;;;;;;qBAmBa,uBAAuB;EAEzB,WAAW;EADpB,YACS,WAAW,eAClB;;;;EAUK,YAAY;;;;EAOH;;EAST;;EAKA;;EAKA;;EAKA,KAAK,4BAAmC;;EAKxC,IAAI,aAAa;;EAKjB,UAAU,gBAAgB;;EAK1B,IAAI,aAAa;;EAKjB,UAAU,gBAAgB;;EAK1B,OAAO,gBAAgB;;;;;;;;;;;;;;;EAkBvB,QAAQ,aAAa,aAAa;;;;EAUlC,cAAc,aAAa,aAAa;;EAKxC,OAAO;;EAKP,OAAO,4BAAmC;;EAK1C,OAAO,WAAW,SAAS;;;;;;;EAWrB,SAAS,WAAW,SAAS,gBAAgB,QAAQ;;;;;;;;;;;;EAgElD,aAAa,SAAQ,mBAAqC"}

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

@@ -5,12 +5,12 @@ import { SchemaContext } from "../types/context-types.mjs";
 import { ValidationResult } from "../types/result-types.mjs";
 import { ContextualizedMutator, Mutator } from "../types/mutator-types.mjs";
 import { ContextualizedTransformer, SimpleTransformerCallback, TransformerCallback } from "../types/data-transformer-types.mjs";
-
+import "../types/index.mjs";
 //#region ../../packages/seal/src/validators/base-validator.d.ts
 /**
  * Base validator class - foundation for all validators
  */
-declare class BaseValidator<TInput = unknown, TOutput = TInput> {
+export declare class BaseValidator<TInput = unknown, TOutput = TInput> {
   rules: ContextualSchemaRule[];
   protected refinements: ContextualSchemaRule[];
   mutators: ContextualizedMutator[];
@@ -495,5 +495,4 @@ declare class BaseValidator<TInput = unknown, TOutput = TInput> {
   toJsonSchema(_target?: JsonSchemaTarget): JsonSchemaResult;
 }
 //#endregion
-export { BaseValidator };
 //# sourceMappingURL=base-validator.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"base-validator.d.mts","names":[],"sources":["../../../../../../../../packages/seal/src/validators/base-validator.ts"],"mappings":"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"}
+{"version":3,"file":"base-validator.d.mts","names":[],"sources":["../../../../../../../../packages/seal/src/validators/base-validator.ts"],"mappings":";;;;;;;;;;;;qBAyBa,cAAc,kBAAkB,UAAU;EAC9C,OAAO;YACJ,aAAa;EAChB,UAAU;YACP;YACA;YACA;YACA;YACA;;YAEA;;;;;;;;YASA,oBAEJ,QAAQ,4BAA4B,6BAA6B;YAC7D;;;;;;;;EASH;;;;;;;;EASA,cAAc;;;;YAKX,kBAAkB;;;;;;YAOlB,gBAAgB;;;;YAKhB,sBAAsB;;;;MAKrB;;;;MAQA;;;;;;gBAUG;;;;;EAQP;;;;;;;EAUA;IAAqB;;;;;;;;EAYrB;IAAwB;;;;;;;;;;;;;;;;;;;;EAwBxB,eAAe,WAAW,qBAAqB;;;;;;;;;;;;;;;;;;;EAyB/C,sBAAsB,WAAW,qBAAqB;;;;;;;;;;;;;;;;;;EAwBtD,SAAS,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkCnB,OAAO;;;;;EAUD,4BAA4B,WAAW,SAAS,gBAAa;;;;;;;;;;;;;;;;;;EA4BnE,WAAW,YAAY,wBAAwB;;;;EAY/C,gBAAgB,YAAY;;;;EAY5B,SAAS;;;;;;;;;;;;;;;;;;;;;;;EA4BT,YAAY;;;;;;;;;;;;;;;;;;;EAsBZ;;;;;;;EA+BA,iBAAiB;;;;;;;;;;;;;;;;;;EAsBjB;;;;EASA;;;;EAOA;;;;EAOA,QAAQ,UAAU,oBAAoB,mBAC3C,MAAM,WAAW,IACjB,uBACA,UAAS;;;;;;;;;;;;;;;;;;;EAyBJ,gBAAgB,UAAU,oBAAoB,mBACnD,MAAM,WAAW,IACjB,uBACA,UAAS;;;;EAWJ,eAAe,UAAU,oBAAoB,mBAClD,MAAM,WAAW,IACjB,uBACA,UAAS,IACR,qBAAqB;;;;YAWd,WAAW,UAAU,oBAAoB,mBACjD,MAAM,WAAW,IACjB,uBACA,UAAS,IACR,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;EA8CjB,QAAQ,UAAU,oBAAoB,mBAC3C,MAAM,WAAW,IACjB,UAAU;IAAM;;;;;;EAUX,OACL,WACE,OAAO,mDACP,SAAS,kBACN;;YAoBS,aACd,QAAQ,kBACR,SAAS,gBACR,QAAQ;;;;EAkBJ,WAAW,SAAS,SAAS;;;;EAS7B,kBAAkB,SAAS,SAAS;;;;;;;;EAiBpC,QAAQ;IAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoC9B,MACL,kBAEM,QAAQ,4BAA4B,6BAA6B;IAC7D;;;;;EAYC,OAAO,WAAW,SAAS,gBAAa;;;;EAc9C,MAAM;;;;EASA,SAAS,WAAW,SAAS,gBAAgB,QAAQ;;YAclD,cAAc,WAAW,SAAS,gBAAgB,QAAQ;;;;YA8HhE,sBAAsB,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAoDjB,qBAAqB,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;EAyCjD,aAAa,UAAS,mBAAqC"}

package/esm/validators/base-validator.mjs

@@ -672,7 +672,8 @@ var BaseValidator = class {
 			vendor: "seal",
 			types: void 0,
 			validate: async (value) => {
-				return mapToStandardResult(await validate(this, value));
+				const result = await validate(this, value);
+				return mapToStandardResult(result);
 			},
 			jsonSchema: {
 				input: (options) => this.toJsonSchema(options.target),