@stacksjs/validation 0.70.88 → 0.70.90

package/dist/conditional.d.ts

@@ -0,0 +1,59 @@
+import type { Validator } from '@stacksjs/ts-validation';
+/**
+ * Mixin: add `.when()` / `.sometimes()` to a validator instance.
+ *
+ * Mutates the validator in place (assigning the new methods) so the
+ * existing chainable surface (`.required()`, `.minLength()`, etc.)
+ * keeps returning `this`. Returns the same instance with the augmented
+ * type so callers see the new methods on the fluent chain.
+ */
+export declare function withConditionals<V extends Validator<any>>(validator: V): V & ConditionalAPI<V>;
+/**
+ * Evaluate a single `when` clause against a parent object.
+ *
+ * Returns `true` when the conditional should fire (and its refinement
+ * should be applied). Pure function — no side effects, safe to call
+ * during introspection too.
+ */
+export declare function shouldApplyConditional(record: ConditionalRecord<Validator<any>>, parent: Record<string, unknown> | null | undefined): boolean;
+/**
+ * Apply every matching conditional on `base` against `parent`, in
+ * registration order. Returns the (possibly refined) validator that
+ * should be used to validate the field.
+ *
+ * The base validator is NEVER mutated — ts-validation methods like
+ * `.required()` and `.min(3)` MUTATE `this` and return it, so calling
+ * refine functions directly on the base would leak across `validate()`
+ * invocations (each call would compound the previous refinements,
+ * making "VAT required for EU customers" sticky across requests).
+ * {@link cloneValidator} produces an isolated instance the refine
+ * pipeline can safely mutate without polluting the schema definition.
+ */
+export declare function applyConditionals<V extends Validator<any>>(base: V, parent: Record<string, unknown> | null | undefined): V;
+/**
+ * A single `.when()` clause attached to a field validator. Multiple
+ * `.when()` calls stack — they're evaluated in registration order and
+ * each matching one further refines the base validator.
+ */
+export declare interface ConditionalRecord<V extends Validator<any>> {
+  field: string
+  match: unknown | ((value: unknown) => boolean)
+  refine: (validator: V) => V
+}
+/** Anything that has a mutable conditionals array — duck-typed so this
+ *  works across all the ts-validation validator subclasses. */
+export declare interface ValidatorWithConditionals<V extends Validator<any>> {
+  __conditionals?: ConditionalRecord<V>[]
+}
+/**
+ * Conditional-rules surface — apps reach these methods through
+ * `.when()` / `.sometimes()` on any validator the schema proxy returns.
+ */
+export declare interface ConditionalAPI<V extends Validator<any>> {
+  when: (
+    field: string,
+    match: unknown | ((value: unknown) => boolean),
+    refine: (validator: V) => V,
+  ) => V & ConditionalAPI<V>
+  sometimes: () => V & ConditionalAPI<V>
+}

package/dist/file-validator.d.ts

@@ -0,0 +1,65 @@
+/** Factory matching ts-validation's `v.string()` / `v.number()` style. */
+export declare function file(): FileValidator;
+/**
+ * `schema.file()` — chainable validator for uploaded files
+ * (stacksjs/stacks#1856).
+ *
+ * Mirrors the ergonomics of `schema.string()` / `schema.number()` /
+ * `schema.enum()` from ts-validation but targets the `UploadedFile`
+ * shape that `req.file('avatar')` / `req.files` return. Conforms to the
+ * `{ rule: { validate(value): { valid, errors? } } }` contract that the
+ * Action layer ({@link `@stacksjs/router`} → `validateActionInput`)
+ * iterates, so file validations slot into the same `validations:` block
+ * as the rest of the field rules:
+ *
+ * @example
+ * ```ts
+ * new Action({
+ *   method: 'POST',
+ *   validations: {
+ *     avatar: { rule: schema.file().image().maxBytes(2 * 1024 * 1024) },
+ *   },
+ *   async handle(req) {
+ *     const file = req.file('avatar')!
+ *     const { url } = await Storage.put(file, { disk: 'public', dir: 'avatars' })
+ *     // …
+ *   },
+ * })
+ * ```
+ *
+ * The validator is intentionally narrow on the input it accepts: a
+ * structural shape with `size: number` and either `mimetype` or
+ * `mimeType`, optionally with `originalName` / `name`. Both the
+ * router's wrapping `UploadedFile` class and the raw multipart-parse
+ * shape satisfy it.
+ */
+/** Shape this validator runs against. */
+export declare interface FileLike {
+  size: number
+  mimetype?: string
+  mimeType?: string
+  originalName?: string
+  name?: string
+}
+declare interface ValidationError { message: string }
+declare interface ValidationResult { valid: boolean, errors?: ValidationError[] }
+/**
+ * Chainable file validator. Each method returns `this` so callers can
+ * stack constraints in any order; rules accumulate into an internal
+ * list and run sequentially on `.validate()`.
+ *
+ * Designed to be cheap to construct — most validators in an Action's
+ * `validations:` block are built once at module load. No I/O happens
+ * here; image dimension / content-sniffing rules belong in a separate
+ * `@stacksjs/storage/image` opt-in (deliverable 5 of #1856).
+ */
+export declare class FileValidator {
+  required(): this;
+  image(): this;
+  mimeTypes(allowed: string[]): this;
+  maxBytes(max: number): this;
+  minBytes(min: number): this;
+  extensions(allowed: string[]): this;
+  custom(rule: (file: FileLike) => string | null): this;
+  validate(value: unknown): ValidationResult;
+}

package/dist/index.d.ts

@@ -0,0 +1,40 @@
+export type {
+  ConditionalAPI,
+  ConditionalRecord,
+  ObjectWithContextValidator,
+  ValidatorWithConditionals,
+} from './schema';
+// Type guard utilities
+export declare function isString(value: unknown): value is string;
+export declare function isNumber(value: unknown): value is number;
+export declare function isBoolean(value: unknown): value is boolean;
+export declare function isObject(value: unknown): value is Record<string, unknown>;
+export declare function isArray(value: unknown): value is unknown[];
+export declare function isFunction(value: unknown): value is Function;
+export declare function isUndefined(value: unknown): value is undefined;
+export declare function isNull(value: unknown): value is null;
+export declare function isNullOrUndefined(value: unknown): value is null | undefined;
+// Order matters: bind `schema` first so any consumer that imports it
+// transitively — validator.ts → schema, plus any user model that lands
+// inside the auto-imports barrel — sees the Proxy rather than an empty
+// namespace placeholder. With this export below the others, ESM consumers
+// arriving mid-evaluation through the auto-imports graph would race the
+// `export *` re-exports from `@stacksjs/ts-validation` (which also exports
+// a `schema` symbol) and see whichever binding was registered first.
+export { schema } from './schema';
+// Conditional validation surface — `.when()` / `.sometimes()` mixins +
+// context-aware object validator (stacksjs/stacks#1890).
+export {
+  applyConditionals,
+  objectWithContext,
+  shouldApplyConditional,
+  withConditionals,
+} from './schema';
+// Re-export everything from @stacksjs/ts-validation. The explicit `schema`
+// export above shadows ts-validation's own `schema` for `import { schema }
+// from '@stacksjs/validation'` consumers — which is what we want, since the
+// Proxy keeps `schema.<method>()` reactive across module-graph races.
+export * from '@stacksjs/ts-validation';
+// Export local validation helpers
+export * from './reporter';
+export * from './validator';

package/dist/index.js

@@ -0,0 +1,2 @@
+// @bun
+var H=import.meta.require;import{v as b}from"@stacksjs/ts-validation";var h=new Set(["image/jpeg","image/png","image/webp","image/gif","image/avif"]);function K(B){return B.mimetype??B.mimeType}function f(B){return B.originalName??B.name}function g(B){let D=f(B);if(!D)return null;let J=D.lastIndexOf(".");if(J<=0||J===D.length-1)return null;let L=D.slice(J+1).toLowerCase();return/^[a-z0-9]+$/.test(L)?L:null}class F{_required=!1;_rules=[];required(){return this._required=!0,this}image(){return this._rules.push((B)=>{let D=K(B);if(!D||!h.has(D.toLowerCase()))return`must be an image (got ${D||"no mimetype"})`;return null}),this}mimeTypes(B){let D=new Set(B.map((J)=>J.toLowerCase()));return this._rules.push((J)=>{let L=K(J);if(!L||!D.has(L.toLowerCase()))return`must be one of: ${B.join(", ")} (got ${L||"no mimetype"})`;return null}),this}maxBytes(B){return this._rules.push((D)=>{if(typeof D.size!=="number")return"has no size \u2014 cannot enforce maxBytes";if(D.size>B)return`is too large: ${D.size} bytes exceeds the ${B}-byte cap`;return null}),this}minBytes(B){return this._rules.push((D)=>{if(typeof D.size!=="number")return"has no size \u2014 cannot enforce minBytes";if(D.size<B)return`is too small: ${D.size} bytes is below the ${B}-byte minimum`;return null}),this}extensions(B){let D=new Set(B.map((J)=>J.toLowerCase().replace(/^\./,"")));return this._rules.push((J)=>{let L=g(J);if(!L||!D.has(L))return`must have one of these extensions: ${B.join(", ")} (got ${L?`.${L}`:"no extension"})`;return null}),this}custom(B){return this._rules.push(B),this}validate(B){if(B===null||B===void 0){if(this._required)return{valid:!1,errors:[{message:"is required"}]};return{valid:!0}}if(typeof B!=="object"||typeof B.size!=="number")return{valid:!1,errors:[{message:"must be an uploaded file"}]};let D=B,J=[];for(let L of this._rules){let U=L(D);if(U)J.push({message:U})}return J.length===0?{valid:!0}:{valid:!1,errors:J}}}function q(){return new F}function T(B){let D=B;return D.when=function(L,U,Q){if(!this.__conditionals)this.__conditionals=[];return this.__conditionals.push({field:L,match:U,refine:Q}),this},D.sometimes=function(){return this.optional(),this},D}function A(B,D){if(D===null||D===void 0)return!1;let J=D[B.field];if(typeof B.match==="function")return B.match(J);return J===B.match}function V(B,D){let J=B.__conditionals;if(!J||J.length===0)return B;let L=null;for(let U of J){if(!A(U,D))continue;if(L===null)L=y(B);L=U.refine(L)}return L??B}function y(B){let D=Object.create(Object.getPrototypeOf(B));Object.assign(D,B);let J=B.rules;if(Array.isArray(J))D.rules=J.slice();return D}function I(B){let D=B??{},J=!0,L={name:"object",get isRequired(){return J},getRules:()=>[],test(Q){return this.validate(Q).valid},isPartOfShape:!1,shape(Q){return D=Q,L},getShape(){return D},required(){return J=!0,U},optional(){return J=!1,U},validate(Q){let Z=Q===void 0||Q===null;if(!J&&Z)return{valid:!0,errors:this.isPartOfShape?{}:[]};if(J&&Z)return this.isPartOfShape?{valid:!1,errors:{object:[{message:"value is required"}]}}:{valid:!1,errors:[{message:"value is required"}]};if(typeof Q!=="object"||Array.isArray(Q))return this.isPartOfShape?{valid:!1,errors:{object:[{message:"Must be an object"}]}}:{valid:!1,errors:[{message:"Must be an object"}]};let $=Q,X={},G=!1;for(let N of Object.keys(D)){let _=D[N];if(!_)continue;let Y=V(_,$),S=$[N],P=Y.validate(S);if(P.valid)continue;if(G=!0,!Array.isArray(P.errors))for(let[w,k]of Object.entries(P.errors))X[`${N}.${w}`]=k;else X[N]=P.errors}if(G)return{valid:!1,errors:X};return{valid:!0,errors:{}}}},U=T(L);return U}var v=new Set(["array","bigint","binary","blob","boolean","custom","date","datetime","decimal","double","enum","float","integer","json","number","password","smallint","string","text","time","timestamp","timestampTz","unix"]);function m(B){return(...D)=>{let J=B(...D);return T(J)}}var W=new Proxy(b,{get(B,D,J){if(D==="file")return q;if(D==="object")return I;if(typeof D==="string"&&v.has(D)){let L=Reflect.get(B,D,J);if(typeof L==="function")return m(L)}return Reflect.get(B,D,J)}});export*from"@stacksjs/ts-validation";var M=[];function O(B){M=B}function UB(){return M}import{HttpError as z}from"@stacksjs/error-handling";import{path as R}from"@stacksjs/path";import{snakeCase as p}from"@stacksjs/strings";import{getErrorMessage as C}from"@stacksjs/utils";import{MessageProvider as E,setCustomMessages as x}from"@stacksjs/ts-validation";function c(B,D={}){let J=[];for(let L of B){let Q=L.startsWith("/")?L.lastIndexOf("/"):-1,Z=L.indexOf("*"),$=Z===-1?Q:L.lastIndexOf("/",Z),X=$>0?L.slice(0,$):".",G=$>0?L.slice($+1):L,N=new Bun.Glob(G);for(let _ of N.scanSync({cwd:X,onlyFiles:!0}))J.push(D.absolute?`${X}/${_}`:_)}return J}function WB(B){if(B===void 0)return!1;return Object.keys(B).length>0}async function d(B,D){let L=c([R.userModelsPath("*.ts"),R.storagePath("framework/defaults/app/Models/**/*.ts")],{absolute:!0}).find((X)=>X.endsWith(`${B}.ts`));if(!L)throw new z(404,`Model ${B} not found`);let Q=(await import(L)).default.attributes,Z={},$={};for(let X in Q)if(Object.prototype.hasOwnProperty.call(Q,X)){let G=Q[X];if(!G)continue;let N="isRequired"in(G.validation?.rule??{})?(G.validation?.rule).isRequired:!1;if(G.default!==void 0&&N===!1)continue;Z[p(X)]=G.validation?.rule;let _=G.validation?.message;if(_)for(let Y in _){let S=`${X}.${Y}`;$[S]=_[Y]||""}}try{x(new E($));let G=await W.object(Z).validate(D);if(!G.valid)throw O(G.errors),new z(422,"Validation failed",{errors:G.errors});return G}catch(X){if(X instanceof z)throw X;throw new z(500,C(X)||"An unexpected validation error occurred")}}var j=new Map;function YB(B,D){j.set(B,D)}function PB(B){return j.get(B)}function VB(B,D,J){return async(L)=>{try{let{db:U}=await import("@stacksjs/database"),Q=U.selectFrom(B).where(D,"=",L);if(J)Q=Q.where("id","!=",J);return await Q.selectAll().executeTakeFirst()?`The ${D} has already been taken`:!0}catch{return!0}}}function IB(B,D){return async(J)=>{try{let{db:L}=await import("@stacksjs/database");return await L.selectFrom(B).where(D,"=",J).selectAll().executeTakeFirst()?!0:`The selected ${D} does not exist`}catch{return!0}}}async function SB(B,D,J){let L=await d(B,D);if(J&&Object.keys(J).length>0){let U={};if(await Promise.all(Object.entries(J).map(async([Q,Z])=>{let $=await Z(D[Q],D);if($!==!0)U[Q]=typeof $==="string"?$:`${Q} validation failed`})),Object.keys(U).length>0)throw new z(422,"Validation failed",{errors:U})}return L}async function n(B){if(!B||typeof B!=="object")return{};if(typeof B.all==="function"){let L=B.all();return L instanceof Promise?await L:L}let D=B,J={};if(D.url)try{new URL(D.url).searchParams.forEach((U,Q)=>{J[Q]=U})}catch{}if(D.query&&typeof D.query==="object")Object.assign(J,D.query);if(D.jsonBody&&typeof D.jsonBody==="object")Object.assign(J,D.jsonBody);if(D.formBody&&typeof D.formBody==="object")Object.assign(J,D.formBody);if(D.params&&typeof D.params==="object")Object.assign(J,D.params);if(Object.keys(J).length===0&&!("all"in B)&&!("jsonBody"in B))return B;return J}async function AB(B,D){let J=await n(B),L={},U={};for(let[Q,Z]of Object.entries(D)){if(!Z)continue;if(typeof Z.rule==="object"||typeof Z.rule==="function"){L[Q]=Z.rule;let $=Z.message;if(typeof $==="string")U[`${Q}.default`]=$;else if($&&typeof $==="object")for(let[X,G]of Object.entries($))U[`${Q}.${X}`]=G}else L[Q]=Z}try{if(Object.keys(U).length>0)x(new E(U));let Z=await W.object(L).validate(J);if(!Z.valid){let X={};for(let G of Z.errors||[]){let N=G.field??"_";if(!X[N])X[N]=[];X[N].push(G.message)}throw new z(422,"Validation failed",{errors:X})}return Z.value??J}catch(Q){if(Q instanceof z)throw Q;throw new z(500,C(Q)||"An unexpected validation error occurred")}}async function CB(B,D){let J={},L={};for(let U in B)if(Object.prototype.hasOwnProperty.call(B,U)){let Q=B[U]?.rule;if(Q)J[U]=Q;let Z=B[U]?.message;for(let $ in Z){let X=`${U}.${$}`;L[X]=B[U]?.message[$]||""}}try{let Q=await W.object().shape(J).validate(D);if(!Q.valid)throw new z(422,"Validation failed",{errors:Q.errors});return Q}catch(U){if(U instanceof z)throw U;throw new z(500,C(U)||"An unexpected validation error occurred")}}function KB(B){return typeof B==="string"}function FB(B){return typeof B==="number"&&!Number.isNaN(B)}function qB(B){return typeof B==="boolean"}function MB(B){return typeof B==="object"&&B!==null&&!Array.isArray(B)}function OB(B){return Array.isArray(B)}function RB(B){return typeof B==="function"}function EB(B){return B===void 0}function xB(B){return B===null}function jB(B){return B===null||B===void 0}export{T as withConditionals,SB as validateFieldAsync,d as validateField,AB as validate,VB as unique,A as shouldApplyConditional,W as schema,O as reportError,YB as registerRule,I as objectWithContext,EB as isUndefined,KB as isString,WB as isObjectNotEmpty,MB as isObject,FB as isNumber,jB as isNullOrUndefined,xB as isNull,RB as isFunction,qB as isBoolean,OB as isArray,UB as getErrors,PB as getCustomRule,IB as exists,CB as customValidate,V as applyConditionals};

package/dist/object-with-context.d.ts

@@ -0,0 +1,37 @@
+import type { ConditionalAPI } from './conditional';
+import type { ValidationResult, Validator } from '@stacksjs/ts-validation';
+/**
+ * Build a Stacks-flavored object validator that respects conditional
+ * rules on its child validators. Drop-in for `v.object(...)` in
+ * `@stacksjs/ts-validation` — same call shape, broader behavior.
+ *
+ * @example
+ * ```ts
+ * objectWithContext({
+ *   payment_method: schema.enum(['card', 'bank']),
+ *   card_token:     schema.string().when('payment_method', 'card', s => s.required()),
+ *   bank_account:   schema.string().when('payment_method', 'bank', s => s.required()),
+ *   username:       schema.string().sometimes().minLength(3),
+ * }).validate(input)
+ * ```
+ */
+export declare function objectWithContext<T extends Record<string, Validator<any>>>(initialShape?: T): ObjectWithContextValidator<T> & ConditionalAPI<ObjectWithContextValidator<T>>;
+/**
+ * Validator-shaped object returned by `schema.object()`. Mirrors the
+ * subset of ts-validation's `ObjectValidatorType` that Stacks code
+ * actually uses today (`validate`, `shape`, `optional`, `required`).
+ *
+ * Extra method:
+ *   - `getShape()` — exposes the underlying shape map so OpenAPI export
+ *     and other introspection passes can walk the per-field validators
+ *     (and their `__conditionals` arrays).
+ */
+export declare interface ObjectWithContextValidator<T extends Record<string, Validator<any>>> extends Validator<Record<string, unknown>> {
+  readonly name: 'object'
+  validate: (value: unknown) => ValidationResult
+  getShape: () => T
+  required: () => this
+  optional: () => this
+  isPartOfShape: boolean
+  shape: (shape: T) => ObjectWithContextValidator<T>
+}

package/dist/reporter.d.ts

@@ -0,0 +1,7 @@
+export declare function reportError(errors: MessageObject[]): void;
+export declare function getErrors(): MessageObject[];
+declare interface MessageObject {
+  message: string
+  value: string
+  field: string
+}

package/dist/schema.d.ts

@@ -0,0 +1,36 @@
+import { file, FileValidator } from './file-validator';
+import { objectWithContext } from './object-with-context';
+import { withConditionals } from './conditional';
+import type { ConditionalAPI } from './conditional';
+import type { ObjectWithContextValidator } from './object-with-context';
+import type { ValidationInstance } from '@stacksjs/ts-validation';
+export type { FileLike } from './file-validator';
+export type { ConditionalAPI, ConditionalRecord, ValidatorWithConditionals } from './conditional';
+export type { ObjectWithContextValidator } from './object-with-context';
+/**
+ * `Object.assign({}, v, { file })` would defeat the ts-validation
+ * proxy's late-binding. Wrapping with `new Proxy` keeps every existing
+ * `schema.<method>()` call going through the upstream proxy while only
+ * intercepting the slots we own (`file`, `object`, and the conditional
+ * mixin on primitive factories).
+ */
+export declare const schema: SchemaWithFile;
+/**
+ * Extended `ValidationInstance` that adds `schema.file()` on top of the
+ * ts-validation surface (stacksjs/stacks#1856). Upstream ts-validation
+ * has `string()`, `number()`, `enum()`, etc. but no `file()` validator;
+ * we layer one here without forking ts-validation so the rest of the
+ * surface keeps working unchanged.
+ *
+ * The runtime value is the ts-validation proxy with `file` patched in,
+ * `object` swapped for the context-aware variant (stacksjs/stacks#1890),
+ * and every primitive factory wrapped to attach `.when()` / `.sometimes()`
+ * to the returned validator.
+ */
+export type SchemaWithFile = Omit<ValidationInstance, 'object'> & {
+  file: () => FileValidator
+  object: typeof objectWithContext
+}
+export { file, FileValidator } from './file-validator';
+export { applyConditionals, shouldApplyConditional, withConditionals } from './conditional';
+export { objectWithContext } from './object-with-context';

package/dist/validator.d.ts

@@ -0,0 +1,78 @@
+import type { Validator } from '@stacksjs/ts-validation';
+export declare function isObjectNotEmpty(obj: object | undefined): boolean;
+export declare function validateField(modelFile: string, params: RequestData): Promise<any>;
+/**
+ * Register a custom validation rule that can be referenced by name.
+ */
+export declare function registerRule(name: string, rule: AsyncValidator): void;
+/**
+ * Get a registered custom rule by name.
+ */
+export declare function getCustomRule(name: string): AsyncValidator | undefined;
+/**
+ * Built-in async rule: checks that a value is unique in a database table.
+ */
+export declare function unique(table: string, column: string, exceptId?: number): AsyncValidator;
+/**
+ * Built-in async rule: checks that a value exists in a database table.
+ */
+export declare function exists(table: string, column: string): AsyncValidator;
+/**
+ * Validate fields with both sync rules (from model) and async rules.
+ * Runs sync validation first, then async rules, combining all errors.
+ */
+export declare function validateFieldAsync(modelFile: string, params: RequestData, asyncRules?: Record<string, AsyncValidator>): Promise<any>;
+/**
+ * Action-side validation shortcut. Returns the validated input typed as
+ * `T` so callers can drop the post-validate type-cast they used to need.
+ *
+ * Throws `HttpError(422, 'Validation failed', { errors })` on the first
+ * failing field — the router's error handler turns that into a JSON
+ * 422 response automatically.
+ *
+ * @example
+ * ```ts
+ * import { validate, schema } from '@stacksjs/validation'
+ *
+ * type Payload = { email: string; age: number }
+ *
+ * const data = await validate<Payload>(req, {
+ *   email: schema.string().email(),
+ *   age: schema.number().min(0),
+ * })
+ *
+ * // `data.email` is `string`, `data.age` is `number` — no cast needed.
+ * ```
+ */
+export declare function validate<T = Record<string, unknown>>(request: RequestLike | Record<string, unknown>, rules: ValidationRules): Promise<T>;
+export declare function customValidate(attributes: CustomAttributes, params: RequestData): Promise<any>;
+declare interface RequestData {
+  [key: string]: any
+}
+declare interface ValidationField {
+  rule: ValidationType
+  message: Record<string, string>
+}
+declare interface CustomAttributes {
+  [key: string]: ValidationField
+}
+declare interface RequestLike {
+  all?: () => Record<string, unknown> | Promise<Record<string, unknown>>
+  jsonBody?: Record<string, unknown>
+  formBody?: Record<string, unknown>
+  query?: Record<string, unknown>
+  params?: Record<string, unknown>
+  url?: string
+}
+/**
+ * Async validation rule type.
+ * Return true if valid, or a string error message if invalid.
+ */
+// eslint-disable-next-line pickier/no-unused-vars
+export type AsyncValidator = (value: unknown, params: RequestData) => Promise<boolean | string>;
+/**
+ * Shape of a validation rule set understood by `validate()`. Each key
+ * maps to either a raw `Validator<T>` (from `@stacksjs/ts-validation`)
+ * or a `{ rule, message }` object that mirrors the model-attribute form.
+ */
+export type ValidationRules = Record<string, Validator<any> | { rule: Validator<any>, message?: string | Record<string, string> }>;

package/package.json

@@ -2,7 +2,7 @@
   "name": "@stacksjs/validation",
   "type": "module",
   "sideEffects": false,
-  "version": "0.70.88",
+  "version": "0.70.90",
   "description": "The Stacks Validation ways.",
   "author": "Chris Breuer",
   "contributors": [
@@ -57,7 +57,7 @@
   },
   "devDependencies": {
     "better-dx": "^0.2.16",
-    "@stacksjs/strings": "0.70.88",
-    "@stacksjs/types": "0.70.88"
+    "@stacksjs/strings": "0.70.90",
+    "@stacksjs/types": "0.70.90"
   }
 }