@warlock.js/seal 4.0.171 → 4.1.1

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

@@ -0,0 +1,41 @@
+import { Schema } from "./schema-types.mjs";
+import { SchemaRule } from "./rule-types.mjs";
+
+//#region ../../@warlock.js/seal/src/types/context-types.d.ts
+type RuleTranslation = {
+  rule: SchemaRule;
+  context: SchemaContext;
+  attributes: {
+    input: string;
+    path: string;
+    key: string;
+    value: any;
+    [key: string]: any;
+  };
+};
+type AttributeTranslation = {
+  attribute: string;
+  context: SchemaContext;
+  rule: SchemaRule;
+};
+/**
+ * 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 */
+  translateRule: (ruleTranslation: RuleTranslation) => string;
+  translateAttribute: (attributeTranslation: AttributeTranslation) => string; /** Validation configurations */
+  configurations?: {
+    firstErrorOnly?: boolean;
+  };
+};
+//#endregion
+export { AttributeTranslation, RuleTranslation, SchemaContext };
+//# sourceMappingURL=context-types.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"context-types.d.mts","names":[],"sources":["../../../../../../@warlock.js/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,aAjB3C;EAmBA,cAAA;IACE,cAAA;EAAA;AAAA"}

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

@@ -0,0 +1,29 @@
+import { SchemaContext } from "./context-types.mjs";
+
+//#region ../../@warlock.js/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: {
+  options: any;
+  context: SchemaContext;
+}) => any | Promise<any>;
+/**
+ * Simple transformer callback for outputAs()
+ * First param: the data to transform
+ * Second param: validation context
+ */
+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 = {
+  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

@@ -0,0 +1 @@
+{"version":3,"file":"data-transformer-types.d.mts","names":[],"sources":["../../../../../../@warlock.js/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,IACV,IAAA,OACA,OAAA,EAAS,aAAA,WACA,OAAO;;;;;KAMN,yBAAA;EACV,SAAA,EAAW,mBAAmB;EAC9B,OAAA;AAAA"}

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

@@ -0,0 +1,12 @@
+//#region ../../@warlock.js/seal/src/types/date-types.d.ts
+/**
+ * Week day names for validation
+ */
+type WeekDay = "sunday" | "monday" | "tuesday" | "wednesday" | "thursday" | "friday" | "saturday";
+/**
+ * Week day numbers mapping
+ */
+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

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

package/esm/types/date-types.mjs

@@ -0,0 +1,17 @@
+//#region ../../@warlock.js/seal/src/types/date-types.ts
+/**
+* Week day numbers mapping
+*/
+const WEEK_DAYS = {
+	sunday: 0,
+	monday: 1,
+	tuesday: 2,
+	wednesday: 3,
+	thursday: 4,
+	friday: 5,
+	saturday: 6
+};
+
+//#endregion
+export { WEEK_DAYS };
+//# sourceMappingURL=date-types.mjs.map

package/esm/types/date-types.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"date-types.mjs","names":[],"sources":["../../../../../../@warlock.js/seal/src/types/date-types.ts"],"sourcesContent":["/**\r\n * Week day names for validation\r\n */\r\nexport type WeekDay =\r\n  | \"sunday\"\r\n  | \"monday\"\r\n  | \"tuesday\"\r\n  | \"wednesday\"\r\n  | \"thursday\"\r\n  | \"friday\"\r\n  | \"saturday\";\r\n\r\n/**\r\n * Week day numbers mapping\r\n */\r\nexport const WEEK_DAYS: Record<WeekDay, number> = {\r\n  sunday: 0,\r\n  monday: 1,\r\n  tuesday: 2,\r\n  wednesday: 3,\r\n  thursday: 4,\r\n  friday: 5,\r\n  saturday: 6,\r\n};\r\n"],"mappings":";;;;AAeA,MAAa,YAAqC;CAChD,QAAQ;CACR,QAAQ;CACR,SAAS;CACT,WAAW;CACX,UAAU;CACV,QAAQ;CACR,UAAU;AACZ"}

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

@@ -0,0 +1,8 @@
+//#region ../../@warlock.js/seal/src/types/file.types.d.ts
+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

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

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

@@ -0,0 +1,178 @@
+import { StandardSchemaV1 } from "../standard-schema/types.mjs";
+import { Schema } from "./schema-types.mjs";
+import { BaseValidator } from "../validators/base-validator.mjs";
+import { AnyValidator } from "../validators/any-validator.mjs";
+import { ArrayValidator } from "../validators/array-validator.mjs";
+import { BooleanValidator } from "../validators/boolean-validator.mjs";
+import { ComputedValidator } from "../validators/computed-validator.mjs";
+import { DateValidator } from "../validators/date-validator.mjs";
+import { ObjectValidator } from "../validators/object-validator.mjs";
+import { DiscriminatedUnionValidator } from "../validators/discriminated-union-validator.mjs";
+import { FloatValidator } from "../validators/float-validator.mjs";
+import { InstanceOfValidator } from "../validators/instanceof-validator.mjs";
+import { IntValidator } from "../validators/int-validator.mjs";
+import { LazyValidator } from "../validators/lazy-validator.mjs";
+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";
+//#region ../../@warlock.js/seal/src/types/inference-types.d.ts
+/**
+ * Two inference shapes describe the two halves of the validation pipeline:
+ *
+ * - **`Infer.Input<T>`** — what the *caller* is allowed to send before
+ *   validation runs. `.optional()`, `.default()`, and `.catch()` all make a
+ *   key optional from the caller's perspective: any of them means "you don't
+ *   have to supply this".
+ *
+ * - **`Infer.Output<T>`** — what `validData` contains *after* validation
+ *   passes. Reflects runtime reality: `.default()` and `.catch()` guarantee a
+ *   value, so fields with those brands are non-optional in the output even
+ *   when chained with `.optional()`.
+ *
+ * **Bare `Infer<T>` defaults to `Infer.Input<T>`.** Use the explicit form
+ * (`Infer.Output<T>`) when typing validated data — Cascade `Model<>` type
+ * params, the right-hand-side of a `validate()` call, anywhere downstream
+ * of validation that wants the post-default shape.
+ *
+ * @example
+ * ```ts
+ * const schema = v.object({
+ *   name: v.string(),
+ *   email: v.string().email().optional(),
+ *   deletedAt: v.date().nullable(),
+ *   status: v.string().optional().default("active"),
+ * });
+ *
+ * type In  = Infer.Input<typeof schema>;
+ * // {
+ * //   name: string;
+ * //   email?: string;
+ * //   deletedAt: Date | null;
+ * //   status?: string;            ← caller may omit; default fires
+ * // }
+ *
+ * type Out = Infer.Output<typeof schema>;
+ * // {
+ * //   name: string;
+ * //   email?: string;
+ * //   deletedAt: Date | null;
+ * //   status: string;             ← validData always has it
+ * // }
+ *
+ * type Default = Infer<typeof schema>;
+ * // equivalent to Infer.Input<typeof schema>
+ * ```
+ *
+ * The walker reads four type-level brands that validators attach via their
+ * chain methods:
+ *
+ * - `{ isOptional: true }` — set by `.optional()`
+ * - `{ isNullable: true }` — set by `.nullable()`
+ * - `{ hasDefault: true }` — set by `.default()`
+ * - `{ hasCatch: true }` — set by `.catch()`
+ *
+ * Fields marked with `.omit()` / `.exclude()` are excluded from the inferred
+ * type via the `ComputedValidator` / runtime omission path. Computed and
+ * managed validators surface their declared `TResult` directly.
+ */
+/**
+ * True when the validator's type carries a brand that guarantees a value
+ * will always be present (`.default()` or `.catch()`).
+ */
+type IsGuaranteed<V> = V extends {
+  hasDefault: true;
+} ? true : V extends {
+  hasCatch: true;
+} ? true : false;
+/**
+ * Whether a field should appear as an optional key in the parent object's
+ * *output* shape. Optional ONLY when explicitly `.optional()` AND not
+ * 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 {
+  isOptional: true;
+} ? IsGuaranteed<V> extends true ? false : true : false;
+/**
+ * Whether a field should appear as an optional key in the parent object's
+ * *input* shape. Optional whenever `.optional()`, `.default()`, or `.catch()`
+ * 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 {
+  isOptional: true;
+} | {
+  hasDefault: true;
+} | {
+  hasCatch: true;
+} ? true : false;
+/**
+ * Apply `| null` widening when the validator type carries `{ isNullable: true }`.
+ *
+ * Designed to be applied INSIDE each Infer branch (after type-pattern matching)
+ * rather than as a top-level wrapper, because top-level wrapping creates a
+ * class-recursive evaluation in `ObjectValidator`'s base class type parameter.
+ */
+type WithNullable<V, T> = V extends {
+  isNullable: true;
+} ? T | null : T;
+/**
+ * Compute the inferred *output* object shape for a Schema.
+ *
+ * Exported so `ObjectValidator` can use this in its class definition without
+ * going through the full `Infer.Output<>` walker — referencing the full
+ * walker on the parent class's type parameter creates a recursive class-base
+ * reference when combined with brand-checks.
+ */
+type InferOutputObjectShape<S extends Schema> = { [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> = { [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 {
+  /**
+   * Inferred *input* shape — what callers send before validation. Optional
+   * keys whenever `.optional()`, `.default()`, or `.catch()` is present.
+   */
+  type Input<T> = T extends LazyValidator<infer L> ? Input<L> : T extends DiscriminatedUnionValidator<any, infer Branches> ? Branches extends ReadonlyArray<infer B> ? B extends BaseValidator ? WithNullable<T, Input<B>> : never : never : T extends ObjectValidator<infer S> ? WithNullable<T, InferInputObjectShape<S>> : T extends ArrayValidator ? T extends {
+    validator: infer V extends BaseValidator;
+  } ? WithNullable<T, Array<Input<V>>> : never : T extends LiteralValidator<infer V> ? WithNullable<T, V[number]> : T extends InstanceOfValidator<infer R> ? WithNullable<T, R> : T extends ComputedValidator<infer R> ? R : T extends ManagedValidator<infer R> ? R : T extends StandardSchemaV1<infer V, any> ? WithNullable<T, V> : T extends StringValidator ? WithNullable<T, string> : T extends IntValidator ? WithNullable<T, number> : T extends FloatValidator ? WithNullable<T, number> : T extends BooleanValidator ? WithNullable<T, boolean> : T extends DateValidator ? WithNullable<T, Date> : T extends ScalarValidator ? WithNullable<T, string | number | boolean> : T extends AnyValidator ? any : unknown;
+  /**
+   * Inferred *output* shape — what `validData` contains after validation.
+   * Required keys whenever `.default()` or `.catch()` guarantees a value,
+   * even when chained with `.optional()`.
+   */
+  type Output<T> = T extends LazyValidator<infer L> ? Output<L> : T extends DiscriminatedUnionValidator<any, infer Branches> ? Branches extends ReadonlyArray<infer B> ? B extends BaseValidator ? WithNullable<T, Output<B>> : never : never : T extends ObjectValidator<infer S> ? WithNullable<T, InferOutputObjectShape<S>> : T extends ArrayValidator ? T extends {
+    validator: infer V extends BaseValidator;
+  } ? WithNullable<T, Array<Output<V>>> : never : T extends LiteralValidator<infer V> ? WithNullable<T, V[number]> : T extends InstanceOfValidator<infer R> ? WithNullable<T, R> : T extends ComputedValidator<infer R> ? R : T extends ManagedValidator<infer R> ? R : T extends StandardSchemaV1<infer V, any> ? WithNullable<T, V> : T extends StringValidator ? WithNullable<T, string> : T extends IntValidator ? WithNullable<T, number> : T extends FloatValidator ? WithNullable<T, number> : T extends BooleanValidator ? WithNullable<T, boolean> : T extends DateValidator ? WithNullable<T, Date> : T extends ScalarValidator ? WithNullable<T, string | number | boolean> : T extends AnyValidator ? any : unknown;
+}
+/**
+ * @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>;
+/**
+ * @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>;
+/**
+ * @deprecated Use `InferOutputObjectShape<S>` instead. Kept for back-compat.
+ */
+type InferObjectShape<S extends Schema> = InferOutputObjectShape<S>;
+/**
+ * @deprecated Use `IsOutputOptionalKey<V>` instead. Kept for back-compat.
+ */
+type IsOptionalKey<V> = IsOutputOptionalKey<V>;
+//#endregion
+export { Infer, InferInput, InferInputObjectShape, InferObjectShape, InferOutput, InferOutputObjectShape, IsInputOptionalKey, IsOptionalKey, IsOutputOptionalKey };
+//# sourceMappingURL=inference-types.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"inference-types.d.mts","names":[],"sources":["../../../../../../@warlock.js/seal/src/types/inference-types.ts"],"mappings":"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"}

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

@@ -0,0 +1,27 @@
+import { SchemaContext } from "./context-types.mjs";
+
+//#region ../../@warlock.js/seal/src/types/mutator-types.d.ts
+/**
+ * Mutator context
+ */
+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>;
+/**
+ * Contextualized mutator - mutator with runtime context
+ */
+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

@@ -0,0 +1 @@
+{"version":3,"file":"mutator-types.d.mts","names":[],"sources":["../../../../../../@warlock.js/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"}

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

@@ -0,0 +1,16 @@
+//#region ../../@warlock.js/seal/src/types/result-types.d.ts
+/**
+ * Validation result
+ */
+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 */
+    input: string;
+  }[];
+};
+//#endregion
+export { ValidationResult };
+//# sourceMappingURL=result-types.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"result-types.d.mts","names":[],"sources":["../../../../../../@warlock.js/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;IAEA,KAAA;EAAA;AAAA"}

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

@@ -0,0 +1,52 @@
+import { SchemaContext } from "./context-types.mjs";
+
+//#region ../../@warlock.js/seal/src/types/rule-types.d.ts
+/**
+ * Rule validation result
+ */
+type RuleResult = {
+  isValid: false;
+  error: string;
+  input: string;
+  path: string;
+} | {
+  isValid: true;
+};
+type AttributeValue = string | number;
+type ValidationAttributesList = Record<string, AttributeValue | Record<string, AttributeValue>>;
+/**
+ * Rule options - generic options passed to rules
+ */
+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 */
+  sortOrder?: number;
+};
+/**
+ * Contextualized schema rule - rule with runtime context
+ */
+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
+   */
+  context: {
+    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 */
+    translatableParams: Record<string, string>;
+  };
+};
+//#endregion
+export { ContextualSchemaRule, RuleResult, SchemaRule, SchemaRuleOptions, ValidationAttributesList };
+//# sourceMappingURL=rule-types.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rule-types.d.mts","names":[],"sources":["../../../../../../@warlock.js/seal/src/types/rule-types.ts"],"mappings":";;;;;AAKA;KAAY,UAAA;EAEN,OAAA;EACA,KAAA;EACA,KAAA;EACA,IAAA;AAAA;EAGA,OAAA;AAAA;AAAA,KAGD,cAAA;AAAA,KAEO,wBAAA,GAA2B,MAAA,SAErC,cAAA,GAAiB,MAAA,SAAe,cAAA;AAN5B;;;AAAA,KAYM,iBAAA,YAA6B,MAAM,SAAS,CAAA;AAVrC;AAEnB;;AAFmB,KAeP,UAAA,iBAA2B,iBAAA,GAAoB,iBAAA;EAXzD,gBAaA,IAAA,UAbiB;EAejB,WAAA,WAjB2C;EAmB3C,aAAA,YAnBqC;EAqBrC,QAAA,GACE,IAAA,EAAM,oBAAA,CAAqB,OAAA,GAC3B,KAAA,OACA,OAAA,EAAS,aAAA,KACN,OAAA,CAAQ,UAAA,GAvBI;EAyBjB,mBAAA,WAzB8C;EA2B9C,YAAA,WArBU;EAuBV,SAAA;AAAA;;;;KAMU,oBAAA,iBAAqC,iBAAA,GAAoB,iBAAA,IACnE,UAAA;EA9BuD;AAAA;AAKzD;;EA8BI,OAAA;IACE,YAAA;IACA,OAAA,EAAS,OAAA;IACT,cAAA,EAAgB,wBAAA;IAChB,oBAAA,EAAsB,MAAA,kBAvBf;IAyBP,iBAAA,EAAmB,MAAA,eAxBlB;IA0BD,kBAAA,EAAoB,MAAA;EAAA;AAAA"}

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

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

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

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

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

@@ -0,0 +1,33 @@
+import { JsonSchemaResult, JsonSchemaTarget } from "../standard-schema/json-schema.mjs";
+import { BaseValidator } from "./base-validator.mjs";
+
+//#region ../../@warlock.js/seal/src/validators/any-validator.d.ts
+/**
+ * Any validator - accepts any value
+ */
+declare class AnyValidator extends BaseValidator {
+  /**
+   * Any validator means any value, so we disable the default required requirement.
+   */
+  requiredRule: null;
+  /**
+   * Set is optional to be true
+   */
+  isOptional: boolean;
+  /**
+   * @inheritdoc
+   *
+   * Any validator accepts anything. In JSON Schema, an empty object `{}`
+   * is the permissive schema that accepts any valid JSON value.
+   *
+   * @example
+   * ```ts
+   * v.any().toJsonSchema("draft-2020-12")
+   * // → {}
+   * ```
+   */
+  toJsonSchema(target?: JsonSchemaTarget): JsonSchemaResult;
+}
+//#endregion
+export { AnyValidator };
+//# sourceMappingURL=any-validator.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"any-validator.d.mts","names":[],"sources":["../../../../../../@warlock.js/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"}

package/esm/validators/any-validator.mjs

@@ -0,0 +1,35 @@
+import { applyNullable } from "../standard-schema/json-schema.mjs";
+import { BaseValidator } from "./base-validator.mjs";
+
+//#region ../../@warlock.js/seal/src/validators/any-validator.ts
+/**
+* Any validator - accepts any value
+*/
+var AnyValidator = class extends BaseValidator {
+	constructor(..._args) {
+		super(..._args);
+		this.requiredRule = null;
+		this.isOptional = true;
+	}
+	/**
+	* @inheritdoc
+	*
+	* Any validator accepts anything. In JSON Schema, an empty object `{}`
+	* is the permissive schema that accepts any valid JSON value.
+	*
+	* @example
+	* ```ts
+	* v.any().toJsonSchema("draft-2020-12")
+	* // → {}
+	* ```
+	*/
+	toJsonSchema(target = "draft-2020-12") {
+		const schema = {};
+		if (this.isNullable) applyNullable(schema, target);
+		return schema;
+	}
+};
+
+//#endregion
+export { AnyValidator };
+//# sourceMappingURL=any-validator.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"any-validator.mjs","names":[],"sources":["../../../../../../@warlock.js/seal/src/validators/any-validator.ts"],"sourcesContent":["import type { JsonSchemaResult, JsonSchemaTarget } from \"../standard-schema/json-schema\";\r\nimport { applyNullable } from \"../standard-schema/json-schema\";\r\nimport { BaseValidator } from \"./base-validator\";\r\n\r\n/**\r\n * Any validator - accepts any value\r\n */\r\nexport class AnyValidator extends BaseValidator {\r\n  /**\r\n   * Any validator means any value, so we disable the default required requirement.\r\n   */\r\n  public override requiredRule = null;\r\n\r\n  /**\r\n   * Set is optional to be true\r\n   */\r\n  public override isOptional = true;\r\n\r\n  /**\r\n   * @inheritdoc\r\n   *\r\n   * Any validator accepts anything. In JSON Schema, an empty object `{}`\r\n   * is the permissive schema that accepts any valid JSON value.\r\n   *\r\n   * @example\r\n   * ```ts\r\n   * v.any().toJsonSchema(\"draft-2020-12\")\r\n   * // → {}\r\n   * ```\r\n   */\r\n  public override toJsonSchema(target: JsonSchemaTarget = \"draft-2020-12\"): JsonSchemaResult {\r\n    const schema: JsonSchemaResult = {};\r\n    if (this.isNullable) applyNullable(schema, target);\r\n    return schema;\r\n  }\r\n}\r\n"],"mappings":";;;;;;;AAOA,IAAa,eAAb,cAAkC,cAAc;;;sBAIf;oBAKF;;;;;;;;;;;;;;CAc7B,AAAgB,aAAa,SAA2B,iBAAmC;EACzF,MAAM,SAA2B,CAAC;EAClC,IAAI,KAAK,YAAY,cAAc,QAAQ,MAAM;EACjD,OAAO;CACT;AACF"}

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

@@ -0,0 +1,82 @@
+import { JsonSchemaResult, JsonSchemaTarget } from "../standard-schema/json-schema.mjs";
+import { SchemaContext } from "../types/context-types.mjs";
+import { ValidationResult } from "../types/result-types.mjs";
+import { BaseValidator } from "./base-validator.mjs";
+
+//#region ../../@warlock.js/seal/src/validators/array-validator.d.ts
+/**
+ * Array validator class
+ */
+declare class ArrayValidator extends BaseValidator {
+  validator: BaseValidator;
+  constructor(validator: BaseValidator, errorMessage?: string);
+  /**
+   * Check if value is an array type
+   */
+  matchesType(value: any): boolean;
+  /**
+   * Clone the validator
+   */
+  clone(): this;
+  /** Reverse array order */
+  flip(): this;
+  /** Reverse array order (alias) */
+  reverse(): this;
+  /** Make it has only unique values */
+  onlyUnique(): this;
+  /** Sort array */
+  sort(direction?: "asc" | "desc", key?: string): this;
+  /** Array length must be greater than the given length */
+  minLength(length: number, errorMessage?: string): this;
+  /** Array length must be less than the given length */
+  maxLength(length: number, errorMessage?: string): this;
+  /** Array length must be of the given length */
+  length(length: number, errorMessage?: string): this;
+  /**
+   * Array length must be between min and max (inclusive)
+   *
+   * @param min - Minimum length (inclusive)
+   * @param max - Maximum length (inclusive)
+   *
+   * @example
+   * ```ts
+   * v.array(v.string()).between(1, 10)  // Array must have 1 to 10 items
+   * v.array(v.number()).lengthBetween(5, 20)  // Same using alias
+   * ```
+   *
+   * @category Validation Rule
+   */
+  between(min: number, max: number, errorMessage?: string): this;
+  /**
+   * Alias for between() - array length between min and max
+   */
+  lengthBetween(min: number, max: number, errorMessage?: string): this;
+  /** Array must have unique values */
+  unique(errorMessage?: string): this;
+  /** Array must be sorted */
+  sorted(direction?: "asc" | "desc", errorMessage?: string): this;
+  /** Mutate the data */
+  mutate(data: any, context: SchemaContext): any;
+  /** Validate array
+   *
+   * Absent input (and absent without `.default()`) propagates as `data: undefined`
+   * so the parent ObjectValidator can omit the key. Without this, optional array
+   * fields would silently materialise as `[]` in the validated output.
+   */
+  validate(data: any, context: SchemaContext): Promise<ValidationResult>;
+  /**
+   * @inheritdoc
+   *
+   * Recursively generates JSON Schema for the array items.
+   *
+   * @example
+   * ```ts
+   * v.array(v.string().min(1)).minLength(1).toJsonSchema("draft-2020-12")
+   * // → { type: "array", items: { type: "string", minLength: 1 }, minItems: 1 }
+   * ```
+   */
+  toJsonSchema(target?: JsonSchemaTarget): JsonSchemaResult;
+}
+//#endregion
+export { ArrayValidator };
+//# sourceMappingURL=array-validator.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"array-validator.d.mts","names":[],"sources":["../../../../../../@warlock.js/seal/src/validators/array-validator.ts"],"mappings":";;;;;;;;;cAmBa,cAAA,SAAuB,aAAA;EAEzB,SAAA,EAAW,aAAA;cAAX,SAAA,EAAW,aAAA,EAClB,YAAA;EADkB;;;EAUb,WAAA,CAAY,KAAA;EAoG+C;;;EA7FlD,KAAA,CAAA;EAnBkB;EA4B3B,IAAA,CAAA;EA5BwC;EAiCxC,OAAA,CAAA;EA/BE;EAoCF,UAAA,CAAA;;EAKA,IAAA,CAAK,SAAA,mBAAmC,GAAA;EAzCtC;EA8CF,SAAA,CAAU,MAAA,UAAgB,YAAA;EApC1B;EAyCA,SAAA,CAAU,MAAA,UAAgB,YAAA;EAlCjB;EAuCT,MAAA,CAAO,MAAA,UAAgB,YAAA;EAzBvB;;;;;;;;;;;;;;EA2CA,OAAA,CAAQ,GAAA,UAAa,GAAA,UAAa,YAAA;EAA1B;;;EAUR,aAAA,CAAc,GAAA,UAAa,GAAA,UAAa,YAAA;EAA1B;EAKd,MAAA,CAAO,YAAA;EALiC;EAUxC,MAAA,CAAO,SAAA,mBAAmC,YAAA;EALnC;EAUP,MAAA,CAAO,IAAA,OAAW,OAAA,EAAS,aAAA;EALpB;;;;;;EAgBD,QAAA,CAAS,IAAA,OAAW,OAAA,EAAS,aAAA,GAAgB,OAAA,CAAQ,gBAAA;EAA5C;;;;;;;;;;AA6DoE;EAA1E,YAAA,CAAa,MAAA,GAAQ,gBAAA,GAAqC,gBAAA;AAAA"}