@orieljs/validation 0.1.0-alpha.1 → 0.1.0-alpha.10

package/NOTICE

@@ -7,3 +7,10 @@ This product includes software developed by the Oriel project
 Oriel is licensed under the Apache License, Version 2.0 (see LICENSE).
 The Oriel name and logo are not covered by that license; see TRADEMARKS.md
 (https://github.com/orieljs/framework/blob/main/TRADEMARKS.md).
+
+@orieljs/support (and @orieljs/framework, which bundles it) includes transliteration data from
+voku/portable-ascii (https://github.com/voku/portable-ascii), Copyright (C) 2019 Lars Moelleken, MIT License.
+
+@orieljs/notifications (and @orieljs/framework, which bundles it) includes the HTML and CSS of
+Laravel's default notification mail (laravel/framework, https://github.com/laravel/framework),
+Copyright (c) Taylor Otwell, MIT License.

package/README.md

@@ -0,0 +1,34 @@
+# @orieljs/validation
+
+Validation for Oriel: rules for incoming data, form requests and error messages, as Laravel's validation. It is part of `@orieljs/framework`, which every Oriel app already installs, and is re-exported from it. In an app, import it from `@orieljs/framework`; `@orieljs/validation` is also published on its own.
+
+```bash
+npm install @orieljs/framework
+```
+
+```ts title="app/Http/Requests/StorePostRequest.ts"
+import { FormRequest, Rule } from '@orieljs/framework'
+
+export class StorePostRequest extends FormRequest {
+  rules() {
+    return {
+      title: 'required|string|max:255',
+      slug: ['required', 'alpha_dash', Rule.unique('posts', 'slug')],
+      body: 'required|string',
+      published_at: 'nullable|date',
+    } as const
+  }
+}
+```
+
+In a controller, `await StorePostRequest.validate()` runs `authorize()` and `rules()` and returns the validated data, typed from the rules: write `rules()` with `as const` and no return type (it may be `async`). A failure sends the user back with the errors and the old input, or answers 422 with JSON. `await request().validate(rules)` and `Validator.make(data, rules)` validate without a class, and `Rule.unique()`, `Rule.exists()`, `Rule.in()` and `Rule.password()` build rule objects.
+
+Documentation: https://orieljs.vercel.app/docs/validation
+
+Status: early alpha. APIs will change.
+
+## License
+
+Oriel is open-source software licensed under the Apache License 2.0 (Apache-2.0; see `LICENSE` and `NOTICE`). The Oriel name and logo are trademarks; see `TRADEMARKS.md`.
+
+Website: https://orieljs.vercel.app

package/TRADEMARKS.md

@@ -0,0 +1,33 @@
+# Oriel trademark policy
+
+The Oriel code is open source under the Apache License 2.0. The **Oriel name and logo** are not: the license covers
+the code only (section 6 of the license says so), and the name and logo stay with the project. This page explains
+what you can and can't do with them. The goal is simple: people should always be able to tell what is the real Oriel
+and what isn't.
+
+## You can, without asking
+
+- Use, change, ship and sell the code, as the license allows.
+- Say that your app or package is "built with Oriel", "for Oriel" or "compatible with Oriel".
+- Name a package `oriel-<something>` or `<something>-for-oriel` when it works with Oriel, as long as it is clear that
+  it is not official (for example, don't publish it under the `@orieljs` npm scope).
+- Use the name and logo to write about Oriel, teach it, or link to it, in articles, talks, videos and courses.
+- Use the unmodified logo to point to the project, as it is (no recolouring, cropping or
+  distortion).
+
+## You can't, without written permission
+
+- Call a fork, a modified copy or a competing product "Oriel", or anything likely to be confused with it.
+- Use the name or logo as the name, logo or domain of your own product, company or service.
+- Suggest that the Oriel project made, endorses or supports your work when it doesn't.
+- Sell merchandise with the name or logo.
+
+## Forks
+
+Forks are welcome. Please give yours a different name and logo, keep the `LICENSE` and `NOTICE` files, and say that
+it is based on Oriel.
+
+## Questions
+
+Open an issue at https://github.com/orieljs/framework or email meeeet.dev@gmail.com. If you're unsure whether a use
+is fine, ask; the answer is usually yes.

package/dist/index.d.ts

@@ -1,4 +1,5 @@
-import { OrielError, ValidationError, Rules, MessageBag, ValidationRule, Validator as Validator$1, ValidationFactory, RuleCallback } from '@orieljs/contracts';
+import { OrielError, ValidationError, Rules, InferValidatedType, MessageBag, ValidationRule, TypedValidationRule, RuleTyping, InValue, UploadedFile, Validator as Validator$1, ValidationFactory, RuleCallback } from '@orieljs/contracts';
+export { InferRuleType, InferValidatedType } from '@orieljs/contracts';
 import * as _orieljs_support from '@orieljs/support';
 import { ServiceProvider } from '@orieljs/support';
 
@@ -11,6 +12,16 @@ declare class ValidationErrorImpl extends Error implements ValidationError {
     readonly name = "ValidationError";
     constructor(errors: Record<string, string[]>, errorBag?: string, redirectTo?: string | undefined);
 }
+/**
+ * Laravel's ValidationException, for failing a request by hand:
+ * `throw ValidationException.withMessages({ email: __('auth.failed') })`. Rendered like any validation error: 422 JSON,
+ * or a redirect back with the errors.
+ */
+declare class ValidationException extends ValidationErrorImpl {
+    /** Messages per field, each a string or a list. */
+    static withMessages(messages: Record<string, string | readonly string[]>): ValidationException;
+    constructor(errors: Record<string, string[]>, errorBag?: string, redirectTo?: string);
+}
 declare class AuthorizationErrorImpl extends Error implements OrielError {
     readonly kind: "Authorization";
     readonly status = 403;
@@ -31,34 +42,38 @@ declare class InvalidRuleParameterError extends Error implements OrielError {
     constructor(rule: string, parameter: string, reason: string);
 }
 
+/** The data a FormRequest's validate() returns, typed from its rules(). */
+type ValidatedData<F extends FormRequest> = InferValidatedType<Awaited<ReturnType<F['rules']>>>;
 /**
  * Mirrors Illuminate\Foundation\Http\FormRequest, minus dependency injection by type (Oriel resolves the current
  * request and the ValidationFactory through inject(), never through constructor parameters — see spec §3 rule 5).
  * A subclass only has to implement rules(); authorize()/messages()/attributes() default to Laravel's own defaults.
  */
 declare abstract class FormRequest {
-    abstract rules(): Rules;
+    /** May be async, to await something first: `async rules() { const user = await request().user<User>() … }`. */
+    abstract rules(): Rules | Promise<Rules>;
     authorize(): boolean | Promise<boolean>;
     messages(): Record<string, string>;
     attributes(): Record<string, string>;
     /**
      * `const data = await StorePostRequest.validate()` (spec §4.3). Resolves the current request and the
      * ValidationFactory from the active container, runs authorize() first (throwing AuthorizationErrorImpl if it
-     * returns false), then validates request.all() against rules()/messages()/attributes() and returns the typed
-     * validated data (or throws the 422 ValidationError — see ValidatorImpl.validated()).
+     * returns false), then validates request.all() against rules()/messages()/attributes() and returns the validated
+     * data (or throws the 422 ValidationError — see ValidatorImpl.validated()). The data is typed from rules(): write
+     * it without a return type and with `as const` (`return { title: 'required|string' } as const`), so its rule
+     * strings keep their text; a rules() typed `Rules` gives `Record<string, unknown>`.
      */
-    static validate<T = Record<string, unknown>>(this: new () => FormRequest): Promise<T>;
+    static validate<F extends FormRequest>(this: new () => F): Promise<ValidatedData<F>>;
 }
 
-/** Humanizes a (possibly dotted) attribute key, e.g. "items.0.product_name" -> "items.0.product name". */
+/** Humanizes a (possibly dotted) attribute key, e.g. "items.0.product_name" -> "items.0.product name" ("colors.*" stays). */
 declare function defaultAttributeName(key: string): string;
 declare function applyReplacements(template: string, replacements: Record<string, string>): string;
-/** Laravel's English lang/en/validation.php, reproduced as closely as possible (see plan Notes/assumptions). */
+/** Laravel's English lang/en/validation.php, reproduced as closely as possible. */
 declare const DEFAULT_MESSAGES: Record<string, string>;
 
 declare class MessageBagImpl implements MessageBag {
     private readonly items;
-    /** Not part of the MessageBag contract — used internally by ValidatorImpl and by after() hooks. */
     add(key: string, message: string): void;
     has(key: string): boolean;
     first(key?: string): string | undefined;
@@ -80,6 +95,17 @@ interface RuleContext {
     data: Record<string, unknown>;
     /** Every named rule attached to this field (for size-type resolution: numeric/array/file/string). */
     ruleNames: string[];
+    /** The rule key as written, e.g. "items.*.email" (distinct reads every row of it). */
+    pattern?: string;
+    /**
+     * What the rules keep for one validation pass, such as every row a wildcard names: each pass starts with an empty
+     * one, so nothing outlives the data it was read from. Absent when a rule runs on its own.
+     */
+    cache?: Map<string, unknown>;
+    /** The parameters of rule `name` on `field` (a concrete path), or undefined when that field has no such rule. */
+    getRule?(field: string, name: string): string[] | undefined;
+    /** How a message names `field`: its custom attribute, else the humanized key. */
+    displayName?(field: string): string;
 }
 interface BuiltinRule {
     validate(ctx: RuleContext): boolean | Promise<boolean>;
@@ -89,8 +115,15 @@ interface BuiltinRule {
     replacements?(ctx: RuleContext): Record<string, string>;
     /** Used when messageKey() isn't in DEFAULT_MESSAGES (e.g. an extend()ed rule with a custom message). */
     defaultMessage?: string;
+    /** An extend()ed rule's own message: it wins over the default lines, as Laravel's fallback messages do. */
+    message?: string;
     /** Runs even when the value is missing, blank, or null under nullable (the required* family, and accepted); a failure stops the field. */
     implicit?: boolean;
+    /**
+     * An exclude rule (`exclude`, `exclude_if`, …): it always runs, and when validate() returns false the field and its
+     * children are skipped from then on and left out of the validated data, with no message.
+     */
+    excludes?: boolean;
 }
 type ParsedRule = {
     kind: 'named';
@@ -100,8 +133,18 @@ type ParsedRule = {
     kind: 'object';
     rule: ValidationRule;
 };
-declare function parseRuleSpec(spec: string | ReadonlyArray<string | ValidationRule>): ParsedRule[];
-/** Laravel's definition of "empty" for the required family: null, undefined, '' and []. false and 0 are NOT empty. */
+/**
+ * A rule object that stands for string rules (Rule.requiredIf(), Rule.when(), Rule.array(), …), as Laravel's
+ * ValidationRuleParser reads them: the rules expandRules() returns, given the data, take its place.
+ */
+interface ExpandingRule extends ValidationRule {
+    expandRules(data: Record<string, unknown>): string | ReadonlyArray<string | ValidationRule>;
+}
+declare function parseRuleSpec(spec: string | ReadonlyArray<string | ValidationRule>, data?: Record<string, unknown>): ParsedRule[];
+/**
+ * Laravel's definition of "empty" for the required family (validateRequired()): null, undefined, text that is blank
+ * once trimmed, an empty array and an empty plain object (a JSON object is a PHP array). false and 0 are NOT empty.
+ */
 declare function isEmptyValue(value: unknown): boolean;
 /** Duck-types Contracts/Http's UploadedFile without importing @orieljs/http. */
 declare function isUploadedFileLike(value: unknown): value is {
@@ -114,8 +157,8 @@ declare function isUploadedFileLike(value: unknown): value is {
 /**
  * Expands a `*`-wildcard rule pattern (e.g. "items.*.name") into every concrete path present in `data`
  * (e.g. ["items.0.name", "items.1.name"]). A pattern with no `*` is returned unchanged. A `*` segment whose
- * container is missing, not an array and not a plain object expands to nothing for that branch (Review Focus #4:
- * every reported error is keyed by a concrete path, never the literal pattern). Object keys in UNSAFE_KEYS are
+ * container is missing, not an array and not a plain object expands to nothing for that branch, so every reported
+ * error is keyed by a concrete path, never the literal pattern. Object keys in UNSAFE_KEYS are
  * treated as absent, so a JSON body like {"items":{"__proto__":{...}}} never yields a path through the prototype.
  */
 declare function expandWildcardKeys(pattern: string, data: Record<string, unknown>): string[];
@@ -123,22 +166,162 @@ declare function expandWildcardKeys(pattern: string, data: Record<string, unknow
 /** Every built-in rule, merged. Later tasks (database rules) add their own spread here. */
 declare const builtinRules: Record<string, BuiltinRule>;
 
+/**
+ * Laravel's Illuminate\Validation\Rules\Password: a string of at least `min` characters (8 by default), plus the
+ * checks you add: letters(), mixedCase(), numbers(), symbols(), max(). Every failing check adds its own message.
+ * Rule.password() returns the application default (PasswordRule.defaults()). (Laravel's uncompromised() is not
+ * ported: it calls an outside service.)
+ */
+declare class PasswordRule implements TypedValidationRule<{
+    value: string;
+}> {
+    #private;
+    /** A passing value is a string (for the validated data's type); never set at run time. */
+    readonly __typing?: {
+        value: string;
+    };
+    constructor(min?: number);
+    /** A password rule of at least `size` characters: PasswordRule.min(12).mixedCase(). */
+    static min(size: number): PasswordRule;
+    /**
+     * With an argument, sets the default (Laravel's Password::defaults(fn () => ...), in a provider's boot());
+     * `null` resets it. Without one, returns a copy of the default: PasswordRule.min(8) unless set.
+     */
+    static defaults(): PasswordRule;
+    static defaults(rule: PasswordRule | (() => PasswordRule) | null): void;
+    min(size: number): this;
+    max(size: number): this;
+    /** At least one letter. */
+    letters(): this;
+    /** At least one uppercase and one lowercase letter. */
+    mixedCase(): this;
+    /** At least one number. */
+    numbers(): this;
+    /** At least one symbol (punctuation, a symbol or a space). */
+    symbols(): this;
+    validate(_attribute: string, value: unknown, fail: (message: string) => void): void;
+}
+
 /**
  * Base for the fluent builders. Each one reports under a built-in rule name (`in`, `unique`, `exists`), so when it
  * runs inside a Validator its failure goes through exactly the same lookup as the string rule: custom messages
  * ("email.unique", "items.*.email.unique", "unique"), custom attributes, then the default text. Called directly
  * as a plain ValidationRule, validate() fails with the default English message.
  */
-declare abstract class BuiltinRuleObject implements ValidationRule {
+declare abstract class BuiltinRuleObject<T extends RuleTyping = Record<never, never>> implements TypedValidationRule<T> {
     abstract readonly ruleName: string;
-    abstract passes(attribute: string, value: unknown, data: Record<string, unknown>, expandedFromWildcard?: boolean): boolean | Promise<boolean>;
+    /** What a passing value is, for the validated data's type (`T`); never set at run time. */
+    readonly __typing?: T;
+    /** `ruleNames`: the field's named rules, when it runs inside a Validator (`Rule.in()` reads `array`). */
+    abstract passes(attribute: string, value: unknown, data: Record<string, unknown>, expandedFromWildcard?: boolean, ruleNames?: readonly string[]): boolean | Promise<boolean>;
+    /** The parameters its message shows (`:values` of Rule.doesntContain()), as the string rule's would be. */
+    messageParameters(): string[];
     validate(attribute: string, value: unknown, fail: (message: string) => void, data: Record<string, unknown>, expandedFromWildcard?: boolean): Promise<void>;
 }
-declare class InRule extends BuiltinRuleObject {
+/**
+ * What `Rule.in(values)` lets through. A list the compiler only knows as `string[]` says nothing: any value whose text
+ * is listed passes (the number 1 for '1'), so `string` would be too narrow. A rule string known only as `string` is
+ * treated the same way.
+ */
+type InTyping<V> = string extends V ? Record<never, never> : {
+    value: InValue<V>;
+    each: InValue<V>;
+};
+declare class InRule<V> extends BuiltinRuleObject<InTyping<V>> {
     private readonly values;
     readonly ruleName = "in";
+    constructor(values: readonly V[]);
+    passes(_attribute: string, value: unknown, _data?: Record<string, unknown>, _expanded?: boolean, ruleNames?: readonly string[]): boolean;
+}
+declare class NotInRule extends BuiltinRuleObject {
+    private readonly values;
+    readonly ruleName = "not_in";
     constructor(values: readonly unknown[]);
+    passes(_attribute: string, value: unknown, _data?: Record<string, unknown>, _expanded?: boolean, ruleNames?: readonly string[]): boolean;
+}
+/** A TypeScript enum, or an `as const` object of string and number values. */
+type EnumLike = Record<string, string | number>;
+/**
+ * Laravel's Rule::enum(): one of the enum's values; for a numeric enum, its number or exactly the text of it (a form
+ * sends text: `'1'`, not `'1.0'` or `'01'`). only() and except() narrow the values.
+ */
+declare class EnumRule<E extends EnumLike> extends BuiltinRuleObject<{
+    value: InValue<E[keyof E]>;
+}> {
+    #private;
+    private readonly type;
+    readonly ruleName = "enum";
+    constructor(type: E);
+    only(values: E[keyof E] | ReadonlyArray<E[keyof E]>): this;
+    except(values: E[keyof E] | ReadonlyArray<E[keyof E]>): this;
+    passes(_attribute: string, value: unknown): boolean;
+}
+/** Laravel's Rule::contains() and Rule::doesntContain(): every value is an item of the array, or none is. */
+declare class ContainsRule extends BuiltinRuleObject<{
+    value: unknown[];
+}> {
+    readonly ruleName: 'contains' | 'doesnt_contain';
+    private readonly values;
+    constructor(ruleName: 'contains' | 'doesnt_contain', values: readonly unknown[]);
     passes(_attribute: string, value: unknown): boolean;
+    messageParameters(): string[];
+}
+/** Rules for the field: a rule string, a list, or a callback given the data that returns one. */
+type RuleSet = string | ReadonlyArray<string | ValidationRule> | ((data: Record<string, unknown>) => string | ReadonlyArray<string | ValidationRule>);
+/**
+ * Base for the builders that stand for string rules (Laravel's RequiredIf, ConditionalRules, ArrayRule, Dimensions):
+ * the Validator puts the rules expandRules() returns in their place, so they run only inside a Validator.
+ */
+declare abstract class ExpandingRuleObject<T extends RuleTyping = Record<never, never>> implements ExpandingRule, TypedValidationRule<T> {
+    readonly __typing?: T;
+    abstract expandRules(data: Record<string, unknown>): string | ReadonlyArray<string | ValidationRule>;
+    validate(): never;
+}
+/** Rule.requiredIf(), Rule.excludeIf(), Rule.prohibitedIf(): the rule when the condition holds, else nothing. */
+declare class ConditionalRule<T extends RuleTyping = Record<never, never>> extends ExpandingRuleObject<T> {
+    private readonly rule;
+    private readonly condition;
+    constructor(rule: 'required' | 'exclude' | 'prohibited', condition: boolean | (() => boolean));
+    expandRules(): string;
+}
+/** Laravel's ConditionalRules (Rule.when() and Rule.unless()): one set of rules or the other, chosen from the data. */
+declare class ConditionalRules extends ExpandingRuleObject {
+    private readonly condition;
+    private readonly rules;
+    private readonly defaultRules;
+    private readonly negate;
+    constructor(condition: boolean | ((data: Record<string, unknown>) => boolean), rules: RuleSet, defaultRules: RuleSet, negate?: boolean);
+    expandRules(data: Record<string, unknown>): string | ReadonlyArray<string | ValidationRule>;
+}
+/** Laravel's Rule::array(): `array`, or `array:a,b` (an object whose keys are among those named). */
+declare class ArrayRule<K extends string> extends ExpandingRuleObject<{
+    value: [K] extends [never] ? unknown[] : {
+        [P in K]?: unknown;
+    };
+}> {
+    private readonly keys;
+    constructor(keys: readonly K[]);
+    expandRules(): string;
+}
+type DimensionConstraints = Partial<Record<'width' | 'height' | 'min_width' | 'min_height' | 'max_width' | 'max_height' | 'ratio', number>>;
+/** Laravel's Rule::dimensions(): the dimensions rule, from an object or fluently (`.maxWidth(1000).ratio(3 / 2)`). */
+declare class DimensionsRule extends ExpandingRuleObject<{
+    value: UploadedFile;
+}> {
+    #private;
+    constructor(constraints: DimensionConstraints);
+    width(pixels: number): this;
+    height(pixels: number): this;
+    minWidth(pixels: number): this;
+    minHeight(pixels: number): this;
+    maxWidth(pixels: number): this;
+    maxHeight(pixels: number): this;
+    /** Width over height: `ratio(3 / 2)`. */
+    ratio(ratio: number): this;
+    /** `dimensions:max_width=1000,ratio=1.5`, Laravel's __toString(). */
+    toString(): string;
+    expandRules(): string;
+    private set;
 }
 declare class UniqueRule extends BuiltinRuleObject {
     private readonly table;
@@ -166,30 +349,36 @@ declare class ExistsRule extends BuiltinRuleObject {
 }
 /** Fluent rule-object builders, for when a plain string rule can't express what's needed (e.g. .ignore()). */
 declare const Rule: {
-    in: (values: readonly unknown[]) => InRule;
+    /** One of `values`, compared as text (as `in:a,b`); typed as those values: `Rule.in(['draft', 'publish'])`. */
+    in: <const V extends readonly unknown[]>(values: V) => InRule<V[number]>;
+    /** None of `values`, compared as text (as `not_in:a,b`). */
+    notIn: (values: readonly unknown[]) => NotInRule;
+    /** One of a TypeScript enum's values (or an `as const` object's): `Rule.enum(Status)`, `.only([…])`, `.except([…])`. */
+    enum: <E extends EnumLike>(type: E) => EnumRule<E>;
+    /** An array holding every one of `values`. */
+    contains: (values: readonly unknown[]) => ContainsRule;
+    /** An array holding none of `values`. */
+    doesntContain: (values: readonly unknown[]) => ContainsRule;
+    /** `required` when the condition (or the callback) holds. */
+    requiredIf: (condition: boolean | (() => boolean)) => ConditionalRule;
+    /** `exclude` when the condition (or the callback) holds; the key is optional, as `exclude_if` makes it. */
+    excludeIf: (condition: boolean | (() => boolean)) => ConditionalRule<{
+        presence: "optional";
+    }>;
+    /** `prohibited` when the condition (or the callback) holds. */
+    prohibitedIf: (condition: boolean | (() => boolean)) => ConditionalRule;
+    /** `rules` when the condition (or the callback, given the data) holds, else `defaultRules`. */
+    when: (condition: boolean | ((data: Record<string, unknown>) => boolean), rules: RuleSet, defaultRules?: RuleSet) => ConditionalRules;
+    /** `rules` unless the condition (or the callback, given the data) holds, else `defaultRules`. */
+    unless: (condition: boolean | ((data: Record<string, unknown>) => boolean), rules: RuleSet, defaultRules?: RuleSet) => ConditionalRules;
+    /** `array`, or with keys `array:name,email` (an object whose keys are among those named). */
+    array: <const K extends string = never>(keys?: readonly K[]) => ArrayRule<K>;
+    /** The dimensions rule: `Rule.dimensions().maxWidth(1000).ratio(3 / 2)`, or `Rule.dimensions({ min_width: 100 })`. */
+    dimensions: (constraints?: DimensionConstraints) => DimensionsRule;
     unique: (table: string, column?: string) => UniqueRule;
     exists: (table: string, column?: string) => ExistsRule;
-};
-
-/** See Task 9's writeup in the plan for exactly what this does and doesn't infer. */
-type SplitPipe<S extends string> = S extends `${infer Head}|${infer Tail}` ? Head | SplitPipe<Tail> : S;
-type RuleName<T extends string> = T extends `${infer Name}:${string}` ? Name : T;
-type Names<S extends string> = RuleName<SplitPipe<S>>;
-type BaseType<S extends string> = 'array' extends Names<S> ? unknown[] : 'boolean' extends Names<S> ? boolean : 'integer' extends Names<S> ? number : 'numeric' extends Names<S> ? number : 'email' extends Names<S> ? string : 'url' extends Names<S> ? string : 'uuid' extends Names<S> ? string : 'date' extends Names<S> ? string : 'string' extends Names<S> ? string : unknown;
-/**
- * The inferred type for one rule string, e.g. 'nullable|integer' -> number | null. A non-literal `string` (a rules
- * object declared without `as const`) carries no rule names to read, so it infers unknown: without this guard every
- * `'x' extends string` check would match and the result would wrongly be `unknown[] | null`.
- */
-type InferRuleType<S extends string> = string extends S ? unknown : 'nullable' extends Names<S> ? BaseType<S> | null : BaseType<S>;
-/**
- * Best-effort: applies InferRuleType to every string-valued rule; array-form (mixed string/object) rules -> unknown.
- * Strips `readonly` (via `-readonly`) so a `Rules` object declared `as const` (the common way to get literal rule
- * strings for inference — see the Task 9 type test) still produces a plain, mutable validated-data shape, not a
- * readonly one; a mapped type otherwise carries the source's readonly modifier over by default.
- */
-type InferValidatedType<R> = {
-    -readonly [K in keyof R]: R[K] extends string ? InferRuleType<R[K]> : unknown;
+    /** Laravel's Password::defaults(): the application's password rule (at least 8 characters unless PasswordRule.defaults() changed it). */
+    password: () => PasswordRule;
 };
 
 /**
@@ -201,7 +390,7 @@ type InferValidatedType<R> = {
  * - `sometimes` skips a missing field entirely;
  * - a field stops validating after its first failure under `bail`, or after any implicit rule fails.
  */
-declare class ValidatorImpl implements Validator$1 {
+declare class ValidatorImpl<R extends Rules = Rules> implements Validator$1<R> {
     private readonly data;
     private readonly rules;
     private readonly customMessages;
@@ -211,16 +400,40 @@ declare class ValidatorImpl implements Validator$1 {
     private bag;
     private ranPromise;
     private readonly afterCallbacks;
-    constructor(data: Record<string, unknown>, rules: Rules, customMessages: Record<string, string>, customAttributes: Record<string, string>, registry: Record<string, BuiltinRule>, errorBagName?: string);
+    private parsedRules;
+    /** The fields an exclude rule took out (with their children). */
+    private readonly excluded;
+    /** The same fields as a tree of segment runs from the root, so a lookup reads the field once. */
+    private readonly excludedRuns;
+    /** What the rules keep while one pass runs (RuleContext.cache); a new pass starts with a new one. */
+    private cache;
+    constructor(data: Record<string, unknown>, rules: R, customMessages: Record<string, string>, customAttributes: Record<string, string>, registry: Record<string, BuiltinRule>, errorBagName?: string);
     after(callback: (validator: Validator$1) => void | Promise<void>): this;
-    /** Not part of the Validator contract — lets an after() hook add a failure (MessageBag itself is read-only). */
+    /** Lets an after() hook add a failure. */
     fail(field: string, message: string): void;
     passes(): Promise<boolean>;
     fails(): Promise<boolean>;
     errors(): MessageBagImpl;
-    validated<T = Record<string, unknown>>(): Promise<T>;
+    validated<T = InferValidatedType<R>>(): Promise<T>;
+    /** Takes the field (with its children) out of validation and of the validated data. */
+    private exclude;
+    /**
+     * Laravel's shouldBeExcluded(): the field, or one of its parents, was taken out by an exclude rule. The field's
+     * segments are followed from the root (so `user` takes out `user.name`, not `username`) and each is read once,
+     * however many fields were excluded and however many dots the field holds.
+     */
+    private isExcluded;
     private fieldsFor;
+    private parsed;
+    /** The rule key a concrete field falls under: itself, else the first wildcard key that matches it. */
+    private patternOf;
+    /** Laravel's getRule(): the parameters of rule `name` on `field`, or undefined when the field has no such rule. */
+    private ruleParameters;
+    /** Laravel's getDisplayableAttribute(): a custom attribute for the field or its rule key, else the humanized key. */
+    private displayName;
+    private context;
     private run;
+    private passesExcludeRule;
     private runRule;
     /** Custom message (concrete field, then wildcard pattern, then rule name) or the default, with :attribute filled. */
     private failureMessage;
@@ -228,7 +441,9 @@ declare class ValidatorImpl implements Validator$1 {
 
 declare class ValidationFactoryImpl implements ValidationFactory {
     private readonly extended;
-    make(data: Record<string, unknown>, rules: Rules, messages?: Record<string, string>, attributes?: Record<string, string>): ValidatorImpl;
+    make<const R extends Rules>(data: Record<string, unknown>, rules: R, messages?: Record<string, string>, attributes?: Record<string, string>): ValidatorImpl<R>;
+    /** Every rule this factory knows, built-in and extend()ed, sorted (for editors: `oriel ide:info`). */
+    ruleNames(): string[];
     extend(name: string, callback: RuleCallback, message?: string): void;
 }
 
@@ -239,4 +454,4 @@ declare class ValidationServiceProvider extends ServiceProvider {
     register(): void;
 }
 
-export { AuthorizationErrorImpl, type BuiltinRule, BuiltinRuleObject, DEFAULT_MESSAGES, FormRequest, type InferRuleType, type InferValidatedType, InvalidRuleParameterError, MessageBagImpl, type ParsedRule, Rule, type RuleContext, UnknownValidationRuleError, ValidationErrorImpl, ValidationFactoryImpl, ValidationServiceProvider, Validator, ValidatorImpl, applyReplacements, builtinRules, defaultAttributeName, expandWildcardKeys, isEmptyValue, isUploadedFileLike, parseRuleSpec };
+export { AuthorizationErrorImpl, type BuiltinRule, BuiltinRuleObject, DEFAULT_MESSAGES, type ExpandingRule, FormRequest, InvalidRuleParameterError, MessageBagImpl, type ParsedRule, PasswordRule, Rule, type RuleContext, UnknownValidationRuleError, ValidationErrorImpl, ValidationException, ValidationFactoryImpl, ValidationServiceProvider, Validator, ValidatorImpl, applyReplacements, builtinRules, defaultAttributeName, expandWildcardKeys, isEmptyValue, isUploadedFileLike, parseRuleSpec };