@orieljs/framework 0.1.0-alpha.0 → 0.1.0-alpha.10

package/dist/contracts.d.ts

@@ -35,148 +35,32 @@ interface Container {
 }
 declare const Container: Token<Container>;
 
-interface ServiceProvider {
-    /** Bind things into the container. Synchronous. Don't resolve other services here. */
-    register?(): void;
-    /** Runs after every provider is registered. May be async (e.g. importing route files). */
-    boot?(): void | Promise<void>;
-}
-type ServiceProviderClass = new (app: Application) => ServiceProvider;
-interface Application extends Container {
-    readonly version: string;
-    basePath(path?: string): string;
-    appPath(path?: string): string;
-    bootstrapPath(path?: string): string;
-    configPath(path?: string): string;
-    databasePath(path?: string): string;
-    publicPath(path?: string): string;
-    resourcePath(path?: string): string;
-    storagePath(path?: string): string;
-    /** With no args returns the environment name. With args returns whether it matches any of them. */
-    environment(): string;
-    environment(...environments: string[]): boolean;
-    isProduction(): boolean;
-    isLocal(): boolean;
-    runningInConsole(): boolean;
-    /** Mark the app as running in the console (the CLI entry point calls this). Defaults to true. */
-    setRunningInConsole(value?: boolean): void;
-    runningUnitTests(): boolean;
-    /** Registers the provider. If the app is already booted, the provider is booted immediately. */
-    register(provider: ServiceProvider | ServiceProviderClass): Promise<ServiceProvider>;
-    getProviders(): ServiceProvider[];
-    boot(): Promise<void>;
-    isBooted(): boolean;
-    booting(callback: (app: Application) => void | Promise<void>): void;
-    booted(callback: (app: Application) => void | Promise<void>): void;
-    /** Handle one HTTP request in a fresh request scope via the bound HttpKernel. */
-    handle(request: Request): Promise<Response>;
-    /** Register a callback that terminate() runs, in registration order. */
-    terminating(callback: () => void | Promise<void>): void;
-    terminate(): Promise<void>;
-}
-declare const Application: Token<Application>;
-interface ExceptionHandler {
-    report(error: unknown): Promise<void>;
-    shouldReport(error: unknown): boolean;
-    /** `request` is the scoped HttpRequest (Contracts/Http) when available, else the raw Request. */
-    render(request: unknown, error: unknown): Promise<Response>;
-}
-declare const ExceptionHandler: Token<ExceptionHandler>;
-/** Paths passed to Application.configure().withRouting(). Routing (Wave 1) loads them. */
-interface RoutingPaths {
-    web?: string;
-    api?: string;
-    console?: string;
-    health?: string;
-    apiPrefix: string;
-}
-declare const RoutingPaths: Token<RoutingPaths>;
-/** The object passed to Application.configure().withExceptions(e => …), like Laravel's Exceptions class. */
-interface ExceptionsConfigurator {
-    /** Custom reporting. Return false to stop the default logging. */
-    report(callback: (error: unknown) => void | boolean | Promise<void | boolean>): this;
-    /** Custom rendering. Return undefined to fall through to the default rendering. */
-    render(callback: (error: unknown, request: unknown) => Response | undefined | Promise<Response | undefined>): this;
-    /** Never report errors of these classes. */
-    dontReport(...classes: Array<abstract new (...args: never[]) => Error>): this;
-}
-/** Callbacks collected by withMiddleware()/withExceptions(); invoked by Http / the exception handler (Wave 1). */
-type ConfigCallbacks<T> = Array<(configurator: T) => void>;
-/** Typed as unknown here because MiddlewareConfigurator lives in Contracts/Http; Http casts on use. */
-declare const MiddlewareCallbacks: Token<ConfigCallbacks<unknown>>;
-declare const ExceptionCallbacks: Token<ConfigCallbacks<ExceptionsConfigurator>>;
-
-interface ConfigRepository {
-    has(key: string): boolean;
-    /** Dot notation: get('database.connections.sqlite.database'). */
-    get<T = unknown>(key: string, defaultValue?: T): T;
-    set(key: string, value: unknown): void;
-    set(values: Record<string, unknown>): void;
-    push(key: string, value: unknown): void;
-    all(): Record<string, unknown>;
-}
-declare const ConfigRepository: Token<ConfigRepository>;
-
-interface Arrayable<T = unknown> {
-    toArray(): T;
-}
-interface Jsonable {
-    toJson(): string;
-}
-interface Htmlable {
-    toHtml(): string;
-}
-/** Anything a controller can return that knows how to become a Response. */
-interface Responsable {
-    toResponse(request: unknown): Response | Promise<Response>;
-}
-/** The minimal collection surface contracts rely on (implemented by @orieljs/collections). */
-interface Enumerable<T> extends Iterable<T>, Arrayable<unknown[]> {
-    all(): T[];
-    count(): number;
-    isEmpty(): boolean;
-}
-interface ClassRegistry {
-    /** Registers under `name` (default: cls.name). Throws if the name is already taken by a different class. */
-    register(cls: Class<unknown>, name?: string): string;
-    nameOf(cls: Class<unknown>): string | undefined;
-    resolve<T = unknown>(name: string): Class<T>;
-    has(name: string): boolean;
-}
-declare const ClassRegistry: Token<ClassRegistry>;
-
-type PipeNext<T> = (passable: T) => Promise<unknown>;
-type PipeClosure<T> = (passable: T, next: PipeNext<T>) => Promise<unknown> | unknown;
-/** A class resolved from the container whose `via` method (default 'handle') is called; or a string alias 'name:param1,param2'. */
-type Pipe<T> = PipeClosure<T> | Class<object> | string;
-interface Pipeline<T = unknown> {
-    send(passable: T): this;
-    through(pipes: ReadonlyArray<Pipe<T>>): this;
-    pipe(...pipes: Array<Pipe<T>>): this;
-    /** Method called on class pipes. Default 'handle'. */
-    via(method: string): this;
-    then<R>(destination: (passable: T) => R | Promise<R>): Promise<R>;
-    thenReturn(): Promise<T>;
-}
-interface PipelineFactory {
-    make<T>(): Pipeline<T>;
-}
-declare const PipelineFactory: Token<PipelineFactory>;
-
 /** The session of the current request (scoped). Loaded and saved by the StartSession middleware. */
 interface Session {
     getId(): string;
     start(): Promise<void>;
     save(): Promise<void>;
     all(): Record<string, unknown>;
+    only(keys: string[]): Record<string, unknown>;
+    except(keys: string[]): Record<string, unknown>;
+    /** Whether every key is present, even with a null value. */
+    exists(...keys: string[]): boolean;
+    missing(...keys: string[]): boolean;
+    /** Whether the key is present and not null. */
     has(key: string): boolean;
     get<T = unknown>(key: string, defaultValue?: T): T;
     put(key: string | Record<string, unknown>, value?: unknown): void;
     push(key: string, value: unknown): void;
+    /** Adds `amount` (default 1) to the number under the key and returns the new value. */
+    increment(key: string, amount?: number): number;
+    decrement(key: string, amount?: number): number;
     pull<T = unknown>(key: string, defaultValue?: T): T;
+    /** Forgets the key and returns its value. */
+    remove<T = unknown>(key: string): T;
     forget(...keys: string[]): void;
     flush(): void;
-    flash(key: string, value: unknown): void;
+    /** Puts the value (true when omitted) for the next request only. */
+    flash(key: string, value?: unknown): void;
     now(key: string, value: unknown): void;
     reflash(): void;
     keep(...keys: string[]): void;
@@ -198,6 +82,406 @@ interface SessionHandler {
     gc(maxLifetimeSeconds: number): Promise<void>;
 }
 
+/**
+ * What one rule tells the validated data's type about a value that passed it. Every member is optional:
+ * - `value`: the type of a passing value. A field's type is the intersection of its rules' values
+ *   (`'string|in:a,b'` is `'a' | 'b'`); a field whose rules set none is `unknown`.
+ * - `presence`: `'required'` puts the key in the data and rules out null (`required`, `accepted`); `'present'` puts
+ *   the key in the data; `'filled'` rules out null without putting the key in; `'excluded'` leaves the key out;
+ *   `'optional'` may leave the key out whatever else would put it in (`sometimes` skips a missing key, and a rule that
+ *   excludes the field under a condition drops it with its children), so the key is optional and doesn't put its
+ *   parent in. A key nothing puts in is optional, as the validated data has only the keys the input had.
+ * - `each`: on a field that also has `array`, the type of each item instead of `value` (`in` checks every item of an
+ *   array: `'array|in:a,b'` is `Array<'a' | 'b'>`).
+ * - `nullable`: null passes, unless a `'required'` or `'filled'` rule says otherwise.
+ */
+interface RuleTyping {
+    value?: unknown;
+    each?: unknown;
+    presence?: 'required' | 'present' | 'filled' | 'excluded' | 'optional';
+    nullable?: true;
+}
+/** A number, or the text of one: a form sends every field as text, and `integer` and `numeric` accept both. */
+type NumericValue = number | `${number}`;
+/** `a,b,c` → `'a' | 'b' | 'c'`: a rule's comma-separated parameters, as Validator splits them. */
+type RuleParameterList<P extends string> = P extends `${infer Head},${infer Tail}` ? Head | RuleParameterList<Tail> : P;
+/**
+ * What `in` (and `Rule.in()`) lets through: it compares the value's text with each listed value, so `'1'` lets the
+ * number 1 through too, and `'true'` the boolean. A list known only as `string` (`` `in:${list.join(',')}` ``) says
+ * nothing, as any value whose text is listed passes.
+ */
+type InValue<V> = string extends V ? unknown : V extends string ? V | (V extends `${infer N extends number}` ? N : never) | (V extends 'true' ? true : V extends 'false' ? false : never) : V extends number | boolean ? V | `${V}` : V;
+/**
+ * The string rules that tell the validated data's type something, by name, each a RuleTyping. `Parameters` is the
+ * rule's text after the colon (`'a,b'` for `in:a,b`). A rule that only checks a value it doesn't change the type of
+ * (`max`, `confirmed`, `unique`) has no entry. Add a member for a new type-setting rule; an app adds its own
+ * `Validator.extend()` rules by declaration merging, with the same type parameter.
+ */
+interface ValidationRuleTypes<Parameters extends string = string> {
+    required: {
+        presence: 'required';
+    };
+    /** Skips the field when the key is missing, so the key may be left out even with `required`. */
+    sometimes: {
+        presence: 'optional';
+    };
+    nullable: {
+        nullable: true;
+    };
+    accepted: {
+        presence: 'required';
+        value: true | 1 | 'yes' | 'on' | '1' | 'true';
+    };
+    declined: {
+        presence: 'required';
+        value: false | 0 | 'no' | 'off' | '0' | 'false';
+    };
+    present: {
+        presence: 'present';
+    };
+    filled: {
+        presence: 'filled';
+    };
+    missing: {
+        presence: 'excluded';
+    };
+    exclude: {
+        presence: 'excluded';
+    };
+    /** Drop the field, children and all, under a condition, so the key may be left out even with `required`. */
+    exclude_if: {
+        presence: 'optional';
+    };
+    exclude_unless: {
+        presence: 'optional';
+    };
+    exclude_with: {
+        presence: 'optional';
+    };
+    exclude_without: {
+        presence: 'optional';
+    };
+    /**
+     * Passes only when the field is missing or empty, so a value that is there is null, blank or whitespace-only text,
+     * [] or {}.
+     */
+    prohibited: {
+        value: null | string | [] | Record<string, never>;
+    };
+    string: {
+        value: string;
+    };
+    /** `integer:strict` and `numeric:strict` refuse the text of a number. */
+    integer: {
+        value: Parameters extends 'strict' ? number : NumericValue;
+    };
+    numeric: {
+        value: Parameters extends 'strict' ? number : NumericValue;
+    };
+    /** `boolean:strict` lets only true and false through. */
+    boolean: {
+        value: Parameters extends 'strict' ? boolean : boolean | 0 | 1 | '0' | '1';
+    };
+    /** `array` is a list; `array:a,b` an object whose keys are among those named. */
+    array: {
+        value: Parameters extends '' ? unknown[] : {
+            [K in RuleParameterList<Parameters>]?: unknown;
+        };
+    };
+    list: {
+        value: unknown[];
+    };
+    contains: {
+        value: unknown[];
+    };
+    doesnt_contain: {
+        value: unknown[];
+    };
+    required_array_keys: {
+        value: {
+            [K in RuleParameterList<Parameters>]: unknown;
+        };
+    };
+    in_array_keys: {
+        value: Record<string, unknown>;
+    };
+    email: {
+        value: string;
+    };
+    url: {
+        value: string;
+    };
+    uuid: {
+        value: string;
+    };
+    alpha: {
+        value: string;
+    };
+    alpha_num: {
+        value: string;
+    };
+    alpha_dash: {
+        value: string;
+    };
+    regex: {
+        value: string;
+    };
+    lowercase: {
+        value: string | number;
+    };
+    uppercase: {
+        value: string | number;
+    };
+    ascii: {
+        value: string | number;
+    };
+    hex_color: {
+        value: string;
+    };
+    json: {
+        value: string;
+    };
+    ip: {
+        value: string;
+    };
+    ipv4: {
+        value: string;
+    };
+    ipv6: {
+        value: string;
+    };
+    mac_address: {
+        value: string;
+    };
+    ulid: {
+        value: string;
+    };
+    timezone: {
+        value: string;
+    };
+    active_url: {
+        value: string;
+    };
+    digits: {
+        value: NumericValue;
+    };
+    digits_between: {
+        value: NumericValue;
+    };
+    max_digits: {
+        value: NumericValue;
+    };
+    min_digits: {
+        value: NumericValue;
+    };
+    decimal: {
+        value: NumericValue;
+    };
+    multiple_of: {
+        value: NumericValue;
+    };
+    date: {
+        value: string;
+    };
+    /** A number passes a format made of digits (`Y`, `U`), as in Laravel. */
+    date_format: {
+        value: string | number;
+    };
+    /** A number passes the comparisons as a timestamp, as in Laravel; with `date` in the set, the value is text. */
+    before: {
+        value: string | number;
+    };
+    before_or_equal: {
+        value: string | number;
+    };
+    after: {
+        value: string | number;
+    };
+    after_or_equal: {
+        value: string | number;
+    };
+    date_equals: {
+        value: string | number;
+    };
+    current_password: {
+        value: string;
+    };
+    in: {
+        value: InValue<RuleParameterList<Parameters>>;
+        each: InValue<RuleParameterList<Parameters>>;
+    };
+    file: {
+        value: UploadedFile;
+    };
+    image: {
+        value: UploadedFile;
+    };
+    mimes: {
+        value: UploadedFile;
+    };
+    mimetypes: {
+        value: UploadedFile;
+    };
+    extensions: {
+        value: UploadedFile;
+    };
+    dimensions: {
+        value: UploadedFile;
+    };
+}
+/**
+ * A rule object that tells the validated data's type what it lets through, as a string rule's entry in
+ * ValidationRuleTypes does. `__typing` is never set or read at run time: declare it (`declare readonly __typing?:
+ * { value: string }`). A rule object without it changes nothing, so its field takes the type of the string rules
+ * beside it (`['required', 'string', new Uppercase()]` is a string).
+ */
+interface TypedValidationRule<T extends RuleTyping = RuleTyping> extends ValidationRule {
+    readonly __typing?: T;
+}
+type RuleName<R extends string> = R extends `${infer Name}:${string}` ? Name : R;
+type RuleParameters<R extends string> = R extends `${string}:${infer Parameters}` ? Parameters : '';
+type PipeRules<S extends string> = S extends `${infer Head}|${infer Tail}` ? Head | PipeRules<Tail> : S;
+/** What a rule without an entry, or a rule object without `__typing`, says: nothing. */
+type NoTyping = Record<never, never>;
+type StringRuleTyping<R extends string> = R extends unknown ? RuleName<R> extends keyof ValidationRuleTypes ? ValidationRuleTypes<RuleParameters<R>>[RuleName<R>] : NoTyping : never;
+type ObjectRuleTyping<O> = '__typing' extends keyof O ? Exclude<O['__typing' & keyof O], undefined> : NoTyping;
+type ItemTyping<I> = I extends string ? StringRuleTyping<I> : ObjectRuleTyping<I>;
+/** The typings of one field's rules, as a union: `'required|string'` or `['required', 'string', rule]`. */
+type SpecTypings<Spec> = Spec extends string ? StringRuleTyping<PipeRules<Spec>> : Spec extends ReadonlyArray<infer Item> ? ItemTyping<Item> : NoTyping;
+/** A rule string the compiler only knows as `string` (rules written without `as const`) says nothing. */
+type IsWide<Spec> = Spec extends string ? (string extends Spec ? true : false) : Spec extends ReadonlyArray<infer Item> ? (string extends Extract<Item, string> ? true : false) : false;
+type Intersect<U> = (U extends unknown ? (value: U) => void : never) extends (value: infer I) => void ? I : never;
+type Boxed<T> = T extends {
+    value: infer V;
+} ? {
+    v: V;
+} : never;
+type BoxedEach<T> = T extends {
+    each: infer E;
+} ? {
+    v: E;
+} : never;
+type Unbox<B> = [B] extends [never] ? unknown : Intersect<B> extends {
+    v: infer V;
+} ? V : never;
+type WithoutEach<T> = T extends {
+    each: unknown;
+} ? never : T;
+/** The intersection of the rules' values; on an array, the rules with `each` type its items instead. */
+type ValueOf<T> = [BoxedEach<T>] extends [never] ? Unbox<Boxed<T>> : Unbox<Boxed<WithoutEach<T>>> extends readonly unknown[] ? Array<Unbox<BoxedEach<T>>> : Unbox<Boxed<T>>;
+type PresenceOf<T> = T extends {
+    presence: infer P;
+} ? P : never;
+type NullableOf<T> = T extends {
+    nullable: true;
+} ? true : never;
+interface FieldInfo {
+    value: unknown;
+    required: boolean;
+    optional: boolean;
+    nullable: boolean;
+    excluded: boolean;
+}
+type FieldFrom<T, Optional = [Extract<PresenceOf<T>, 'optional'>] extends [never] ? false : true> = {
+    value: ValueOf<T>;
+    required: Optional extends true ? false : [Extract<PresenceOf<T>, 'required' | 'present'>] extends [never] ? false : true;
+    optional: Optional;
+    nullable: [NullableOf<T>] extends [never] ? false : [Extract<PresenceOf<T>, 'required' | 'filled'>] extends [never] ? true : false;
+    excluded: [Extract<PresenceOf<T>, 'excluded'>] extends [never] ? false : true;
+};
+/** Rules the compiler only knows as `string` say nothing, not even that the key is there. */
+type FieldOf<Spec> = IsWide<Spec> extends true ? NoRules : FieldFrom<SpecTypings<Spec>>;
+type NoRules = {
+    value: unknown;
+    required: false;
+    optional: false;
+    nullable: false;
+    excluded: false;
+};
+type Keys<R> = Extract<keyof R, string>;
+type Head<K extends string> = K extends `${infer H}.${string}` ? H : K;
+type Heads<R> = Head<Keys<R>>;
+type Children<R, H extends string> = {
+    [K in Keys<R> as K extends `${H}.${infer Rest}` ? Rest : never]: R[K];
+};
+type HasChildren<R, H extends string> = [Keys<Children<R, H>>] extends [never] ? false : true;
+type Own<R, H extends string> = H extends keyof R ? FieldOf<R[H]> : NoRules;
+type OrNull<T, Nullable> = Nullable extends true ? T | null : T;
+/**
+ * A wildcard's rules (`items.*.name`) make an array of what they describe; dotted keys (`author.name`) an object.
+ * Without a rule that makes the parent a list (`array`, `list`), validated() may give an object instead: an object
+ * sent under `items.*` stays one, and a sparse match (`{ items: [{}, { qty: 1 }] }`) keeps its index keys.
+ */
+type Structure<C, Parent> = '*' extends Heads<C> ? Items<ValueAt<C, '*'>, Parent> : Shape<C>;
+type Items<V, Parent> = [Parent] extends [readonly unknown[]] ? V[] : V[] | Record<string, V>;
+type ValueAt<R, H extends string, F extends FieldInfo = Own<R, H>> = OrNull<HasChildren<R, H> extends true ? Structure<Children<R, H>, F['value']> : F['value'], F['nullable']>;
+/**
+ * A key is in the data when a rule puts it there, or when a child key without a wildcard is required, unless a rule
+ * may leave it out.
+ */
+type IsRequired<R, H extends string> = Own<R, H>['optional'] extends true ? false : Own<R, H>['required'] extends true ? true : HasChildren<R, H> extends true ? '*' extends Heads<Children<R, H>> ? false : [RequiredHeads<Children<R, H>>] extends [never] ? false : true : false;
+type RequiredHeads<R> = {
+    [H in Heads<R>]: Own<R, H>['excluded'] extends true ? never : IsRequired<R, H> extends true ? H : never;
+}[Heads<R>];
+type Simplify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type Shape<R> = string extends Keys<R> ? Record<string, unknown> : Simplify<{
+    [H in Heads<R> as Own<R, H>['excluded'] extends true ? never : IsRequired<R, H> extends true ? H : never]: ValueAt<R, H>;
+} & {
+    [H in Heads<R> as Own<R, H>['excluded'] extends true ? never : IsRequired<R, H> extends true ? never : H]?: ValueAt<R, H>;
+}>;
+/**
+ * The type of one field's passing value, from its rule string: `'nullable|integer'` → `number | \`${number}\` | null`.
+ * A rule string the compiler only knows as `string` gives unknown.
+ */
+type InferRuleType<S extends string> = string extends S ? unknown : OrNull<FieldOf<S>['value'], FieldOf<S>['nullable']>;
+/**
+ * The validated data a Rules object gives: nested as Validator's validated() nests it (`author.name` → `{ author: {
+ * name } }`, `tags.*` → an array, or an object too unless `tags` has `array` or `list`), each key optional unless a
+ * rule puts it in, each value typed by its rules. Rules known only as `Rules` (or any `Record<string, …>`) give
+ * `Record<string, unknown>`, and rule strings known only as `string` give optional keys of unknown. Write a
+ * FormRequest's `rules()` with `as const` so its rule strings keep their text; `request().validate({ … })` needs
+ * nothing.
+ */
+type InferValidatedType<R> = R extends unknown ? Shape<R> : never;
+
+/** A rule object (Laravel's ValidationRule). Call fail() to reject the value. */
+interface ValidationRule {
+    validate(attribute: string, value: unknown, fail: (message: string) => void, data: Record<string, unknown>): void | Promise<void>;
+}
+/** 'required|string|max:255', or an array mixing strings and rule objects. Keys support dot + `*` wildcards. */
+type Rules = Record<string, string | ReadonlyArray<string | ValidationRule>>;
+interface MessageBag {
+    add(key: string, message: string): void;
+    has(key: string): boolean;
+    first(key?: string): string | undefined;
+    get(key: string): string[];
+    all(): string[];
+    isEmpty(): boolean;
+    count(): number;
+    toObject(): Record<string, string[]>;
+}
+/** `R` is the rules' type: `validated()` is typed from them, as `request().validate()` is. */
+interface Validator<R extends Rules = Rules> {
+    passes(): Promise<boolean>;
+    fails(): Promise<boolean>;
+    /** Only the keys that have rules. Throws ValidationError (Exceptions.ts) on failure. */
+    validated<T = InferValidatedType<R>>(): Promise<T>;
+    /** Valid only after passes()/fails()/validated() has run. */
+    errors(): MessageBag;
+    after(callback: (validator: Validator) => void | Promise<void>): this;
+    /** Adds a failure message for `field` (from an after() hook). */
+    fail(field: string, message: string): void;
+}
+type RuleCallback = (attribute: string, value: unknown, parameters: string[], data: Record<string, unknown>) => boolean | Promise<boolean>;
+interface ValidationFactory {
+    make<const R extends Rules>(data: Record<string, unknown>, rules: R, messages?: Record<string, string>, attributes?: Record<string, string>): Validator<R>;
+    /** Registers a string rule, e.g. extend('uppercase', fn, ':attribute must be uppercase'). */
+    extend(name: string, callback: RuleCallback, message?: string): void;
+}
+declare const ValidationFactory: Token<ValidationFactory>;
+
 /** Web-standard body/headers init types, derived from the runtime's global Response/Headers (no DOM lib needed). */
 type BodyInit = ConstructorParameters<typeof Response>[0];
 type HeadersInit = ConstructorParameters<typeof Headers>[0];
@@ -206,7 +490,13 @@ interface UploadedFile {
     readonly mimeType: string;
     readonly size: number;
     extension(): string;
+    /** The extension of the name the browser gave the file, lower-cased ('' without one). */
+    clientExtension(): string;
+    /** A random 40-character name with extension(): the name store() gives the file. */
+    hashName(): string;
     arrayBuffer(): Promise<ArrayBuffer>;
+    text(): Promise<string>;
+    stream(): ReadableStream<Uint8Array>;
     /** Stores on a Filesystem disk. Returns the stored path. */
     store(directory: string, disk?: string): Promise<string>;
     storeAs(directory: string, name: string, disk?: string): Promise<string>;
@@ -229,6 +519,8 @@ interface HttpRequest {
     header(name: string, defaultValue: string): string;
     bearerToken(): string | undefined;
     ip(): string | undefined;
+    /** The raw body as text (Laravel's getContent()); '' when there is none. */
+    content(): string;
     expectsJson(): boolean;
     ajax(): boolean;
     query<T = unknown>(key?: string, defaultValue?: T): T;
@@ -243,12 +535,23 @@ interface HttpRequest {
     merge(values: Record<string, unknown>): this;
     file(key: string): UploadedFile | undefined;
     cookie(name: string): string | undefined;
+    /** Replace the parsed request cookies (EncryptCookies calls this after decrypting). */
+    setCookies(cookies: Record<string, string>): void;
     /** Route parameter (after model binding), or every parameter when called with no key. */
     route<T = unknown>(key?: string): T;
     session(): Session;
-    /** The user resolved earlier by auth middleware. Undefined for guests. Use `await Auth.user()` to resolve lazily. */
-    user<T = unknown>(guard?: string): T | undefined;
+    /**
+     * The signed-in user, found through the request's guard (the default one, or the one named) the first time it is
+     * asked for, then the same instance for the rest of the request. Undefined for a guest.
+     */
+    user<T = unknown>(guard?: string): Promise<T | undefined>;
+    /** How user() finds the user (Auth sets it). The resolver may return a promise. */
     setUserResolver(resolver: (guard?: string) => unknown): void;
+    /**
+     * Validates this request's input via the ValidationFactory; throws a Validation OrielError (422) on failure. The
+     * validated data is typed from the rules: `validate({ title: 'required|string' })` is `{ title: string }`.
+     */
+    validate<const R extends Rules>(rules: R, messages?: Record<string, string>, attributes?: Record<string, string>): Promise<InferValidatedType<R>>;
 }
 declare const HttpRequest: Token<HttpRequest>;
 type Next = (request: HttpRequest) => Promise<Response>;
@@ -277,6 +580,8 @@ interface MiddlewareConfigurator {
         except: string[];
     }): this;
     redirectGuestsTo(url: string | ((request: HttpRequest) => string)): this;
+    /** Where the `guest` middleware sends a signed-in user. */
+    redirectUsersTo(url: string | ((request: HttpRequest) => string)): this;
 }
 interface HttpKernel {
     handle(request: Request): Promise<Response>;
@@ -287,25 +592,171 @@ interface ResponseFactory {
     make(content?: BodyInit | null, status?: number, headers?: HeadersInit): Response;
     json(data: unknown, status?: number, headers?: HeadersInit): Response;
     noContent(status?: number): Response;
+    /** Renders the view into an HTML response. */
+    view(name: string, data?: Record<string, unknown>, status?: number, headers?: HeadersInit): Promise<Response>;
     download(path: string, name?: string, headers?: HeadersInit): Promise<Response>;
+    /** Sends the file inline, for the browser to show (download() sends it as an attachment). */
+    file(path: string, headers?: HeadersInit): Promise<Response>;
     stream(body: ReadableStream, status?: number, headers?: HeadersInit): Response;
 }
 declare const ResponseFactory: Token<ResponseFactory>;
 
+interface ServiceProvider {
+    /** Bind things into the container. Synchronous. Don't resolve other services here. */
+    register?(): void;
+    /** Runs after every provider is registered. May be async (e.g. importing route files). */
+    boot?(): void | Promise<void>;
+}
+type ServiceProviderClass = new (app: Application) => ServiceProvider;
+interface Application extends Container {
+    readonly version: string;
+    basePath(path?: string): string;
+    appPath(path?: string): string;
+    bootstrapPath(path?: string): string;
+    configPath(path?: string): string;
+    databasePath(path?: string): string;
+    publicPath(path?: string): string;
+    resourcePath(path?: string): string;
+    storagePath(path?: string): string;
+    /** With no args returns the environment name. With args returns whether it matches any of them. */
+    environment(): string;
+    environment(...environments: string[]): boolean;
+    isProduction(): boolean;
+    isLocal(): boolean;
+    runningInConsole(): boolean;
+    /** Mark the app as running in the console (the CLI entry point calls this). Defaults to true. */
+    setRunningInConsole(value?: boolean): void;
+    runningUnitTests(): boolean;
+    /** Registers the provider. If the app is already booted, the provider is booted immediately. */
+    register(provider: ServiceProvider | ServiceProviderClass): Promise<ServiceProvider>;
+    getProviders(): ServiceProvider[];
+    boot(): Promise<void>;
+    isBooted(): boolean;
+    booting(callback: (app: Application) => void | Promise<void>): void;
+    booted(callback: (app: Application) => void | Promise<void>): void;
+    /** Handle one HTTP request in a fresh request scope via the bound HttpKernel. */
+    handle(request: Request): Promise<Response>;
+    /** Register a callback that terminate() runs, in registration order. */
+    terminating(callback: () => void | Promise<void>): void;
+    terminate(): Promise<void>;
+    /**
+     * Register a callback that shutdown() runs once, before the process exits: close pools and clients, write out
+     * files. terminating() callbacks run after every request; these run once, at the end.
+     */
+    onShutdown(callback: () => void | Promise<void>): void;
+    /** Runs the shutdown callbacks once, newest first; a failing one is printed and the rest still run. Never rejects. */
+    shutdown(): Promise<void>;
+}
+declare const Application: Token<Application>;
+interface ExceptionHandler {
+    report(error: unknown): Promise<void>;
+    shouldReport(error: unknown): boolean;
+    /** `request` is the scoped HttpRequest (Contracts/Http) when available, else the raw Request. */
+    render(request: unknown, error: unknown): Promise<Response>;
+}
+declare const ExceptionHandler: Token<ExceptionHandler>;
+/** Paths passed to Application.configure().withRouting(). Routing (Wave 1) loads them. */
+interface RoutingPaths {
+    /** One route file or several, loaded in order (Laravel's `withRouting(web: [...])`). */
+    web?: string | string[];
+    api?: string | string[];
+    console?: string;
+    health?: string;
+    apiPrefix: string;
+}
+declare const RoutingPaths: Token<RoutingPaths>;
+/** The object passed to Application.configure().withExceptions(e => …), like Laravel's Exceptions class. */
+interface ExceptionsConfigurator {
+    /** Custom reporting. Return false to stop the default logging. */
+    report(callback: (error: unknown) => void | boolean | Promise<void | boolean>): this;
+    /** Custom rendering. Return undefined to fall through to the default rendering. */
+    render(callback: (error: unknown, request: unknown) => Response | undefined | Promise<Response | undefined>): this;
+    /** Never report errors of these classes. */
+    dontReport(...classes: Array<abstract new (...args: never[]) => Error>): this;
+    /** Render errors as JSON when the callback returns true, whatever the Accept header. */
+    shouldRenderJsonWhen(callback: (request: HttpRequest, error: unknown) => boolean): this;
+}
+/** Callbacks collected by withMiddleware()/withExceptions(); invoked by Http / the exception handler (Wave 1). */
+type ConfigCallbacks<T> = Array<(configurator: T) => void>;
+/** Typed as unknown here because MiddlewareConfigurator lives in Contracts/Http; Http casts on use. */
+declare const MiddlewareCallbacks: Token<ConfigCallbacks<unknown>>;
+declare const ExceptionCallbacks: Token<ConfigCallbacks<ExceptionsConfigurator>>;
+
+interface ConfigRepository {
+    has(key: string): boolean;
+    /** Dot notation: get('database.connections.sqlite.database'). */
+    get<T = unknown>(key: string, defaultValue?: T): T;
+    set(key: string, value: unknown): void;
+    set(values: Record<string, unknown>): void;
+    push(key: string, value: unknown): void;
+    all(): Record<string, unknown>;
+}
+declare const ConfigRepository: Token<ConfigRepository>;
+
+interface Arrayable<T = unknown> {
+    toArray(): T;
+}
+interface Jsonable {
+    toJson(): string;
+}
+interface Htmlable {
+    toHtml(): string;
+}
+/** Anything a controller can return that knows how to become a Response. */
+interface Responsable {
+    toResponse(request: unknown): Response | Promise<Response>;
+}
+/** The minimal collection surface contracts rely on (implemented by @orieljs/collections). */
+interface Enumerable<T> extends Iterable<T>, Arrayable<unknown[]> {
+    all(): T[];
+    count(): number;
+    isEmpty(): boolean;
+}
+interface ClassRegistry {
+    /** Registers under `name` (default: cls.name). Throws if the name is already taken by a different class. */
+    register(cls: Class<unknown>, name?: string): string;
+    nameOf(cls: Class<unknown>): string | undefined;
+    resolve<T = unknown>(name: string): Class<T>;
+    has(name: string): boolean;
+}
+declare const ClassRegistry: Token<ClassRegistry>;
+
+type PipeNext<T> = (passable: T) => Promise<unknown>;
+type PipeClosure<T> = (passable: T, next: PipeNext<T>) => Promise<unknown> | unknown;
+/** A class resolved from the container whose `via` method (default 'handle') is called; or a string alias 'name:param1,param2'. */
+type Pipe<T> = PipeClosure<T> | Class<object> | string;
+interface Pipeline<T = unknown> {
+    send(passable: T): this;
+    through(pipes: ReadonlyArray<Pipe<T>>): this;
+    pipe(...pipes: Array<Pipe<T>>): this;
+    /** Method called on class pipes. Default 'handle'. */
+    via(method: string): this;
+    then<R>(destination: (passable: T) => R | Promise<R>): Promise<R>;
+    thenReturn(): Promise<T>;
+}
+interface PipelineFactory {
+    make<T>(): Pipeline<T>;
+}
+declare const PipelineFactory: Token<PipelineFactory>;
+
 /** Public method names of a controller (excludes non-function members). */
 type ActionMethods<C> = {
     [K in keyof C]: C[K] extends (...args: any[]) => unknown ? K : never;
 }[keyof C] & string;
 type ControllerAction<C> = readonly [Class<C>, ActionMethods<C>];
 type RouteClosure = (...args: any[]) => unknown;
-type RouteAction = RouteClosure | ControllerAction<any>;
+/** A class with __invoke(): Route.get('/counter', Counter) (single-action controllers, full-page Live components). */
+type InvokableClass = Class<{
+    __invoke(...args: any[]): unknown;
+}>;
+type RouteAction = RouteClosure | ControllerAction<any> | InvokableClass;
 type MiddlewareReference = string | MiddlewareClass;
 interface Route {
     readonly methods: readonly string[];
     readonly uri: string;
     getName(): string | undefined;
     name(name: string): this;
-    middleware(...middleware: MiddlewareReference[]): this;
+    middleware(...middleware: Array<MiddlewareReference | readonly MiddlewareReference[]>): this;
     withoutMiddleware(...middleware: MiddlewareReference[]): this;
     where(parameter: string, pattern: string): this;
     where(patterns: Record<string, string>): this;
@@ -313,7 +764,7 @@ interface Route {
 interface RouteRegistrar {
     prefix(prefix: string): RouteRegistrar;
     name(prefix: string): RouteRegistrar;
-    middleware(...middleware: MiddlewareReference[]): RouteRegistrar;
+    middleware(...middleware: Array<MiddlewareReference | readonly MiddlewareReference[]>): RouteRegistrar;
     controller(controller: Class<unknown>): RouteRegistrar;
     group(routes: () => void | Promise<void>): Promise<void>;
 }
@@ -323,31 +774,51 @@ interface ResourceOptions {
     parameters?: Record<string, string>;
     names?: Record<string, string>;
 }
+/** The route matched for the current request (scope-local; set by the router before route middleware runs). */
+interface CurrentRoute {
+    readonly route: Route;
+    /** Route parameters after model binding, in URI order. */
+    readonly parameters: Record<string, unknown>;
+    /** Resolved route middleware instances, for HttpKernel.terminate(). */
+    readonly middleware: Middleware[];
+}
+declare const CurrentRoute: Token<CurrentRoute>;
 interface Router {
-    get<C>(uri: string, action: ControllerAction<C> | RouteClosure): Route;
-    post<C>(uri: string, action: ControllerAction<C> | RouteClosure): Route;
-    put<C>(uri: string, action: ControllerAction<C> | RouteClosure): Route;
-    patch<C>(uri: string, action: ControllerAction<C> | RouteClosure): Route;
-    delete<C>(uri: string, action: ControllerAction<C> | RouteClosure): Route;
-    options<C>(uri: string, action: ControllerAction<C> | RouteClosure): Route;
-    any<C>(uri: string, action: ControllerAction<C> | RouteClosure): Route;
-    match<C>(methods: string[], uri: string, action: ControllerAction<C> | RouteClosure): Route;
+    get<C>(uri: string, action: ControllerAction<C> | RouteClosure | InvokableClass | string): Route;
+    post<C>(uri: string, action: ControllerAction<C> | RouteClosure | InvokableClass | string): Route;
+    put<C>(uri: string, action: ControllerAction<C> | RouteClosure | InvokableClass | string): Route;
+    patch<C>(uri: string, action: ControllerAction<C> | RouteClosure | InvokableClass | string): Route;
+    delete<C>(uri: string, action: ControllerAction<C> | RouteClosure | InvokableClass | string): Route;
+    options<C>(uri: string, action: ControllerAction<C> | RouteClosure | InvokableClass | string): Route;
+    any<C>(uri: string, action: ControllerAction<C> | RouteClosure | InvokableClass | string): Route;
+    match<C>(methods: string[], uri: string, action: ControllerAction<C> | RouteClosure | InvokableClass | string): Route;
     redirect(from: string, to: string, status?: number): Route;
     view(uri: string, view: string, data?: Record<string, unknown>): Route;
+    /** Route.inertia('/about', 'About', props): a GET route that renders an Inertia page (Laravel's Route::inertia). */
+    inertia(uri: string, component: string, props?: Record<string, unknown>): Route;
     resource(name: string, controller: Class<unknown>, options?: ResourceOptions): void;
     apiResource(name: string, controller: Class<unknown>, options?: ResourceOptions): void;
     fallback(action: RouteAction): Route;
     prefix(prefix: string): RouteRegistrar;
     name(prefix: string): RouteRegistrar;
-    middleware(...middleware: MiddlewareReference[]): RouteRegistrar;
+    middleware(...middleware: Array<MiddlewareReference | readonly MiddlewareReference[]>): RouteRegistrar;
     controller(controller: Class<unknown>): RouteRegistrar;
     /** Explicit model binding: Route.model('author', User). */
     model(parameter: string, model: Class<unknown>): void;
     /** Custom binding resolver. */
     bind(parameter: string, resolver: (value: string) => unknown | Promise<unknown>): void;
     pattern(parameter: string, pattern: string): void;
+    /** Name a middleware class, e.g. aliasMiddleware('auth', Authenticate). */
+    aliasMiddleware(name: string, middleware: MiddlewareClass): this;
+    /** Define (or replace) a middleware group such as 'web' or 'api'. */
+    middlewareGroup(name: string, middleware: MiddlewareReference[]): this;
+    /** Append to a group unless it is already present. */
+    pushMiddlewareToGroup(group: string, middleware: MiddlewareReference): this;
+    getMiddlewareGroups(): Record<string, MiddlewareReference[]>;
     getRoutes(): readonly Route[];
     current(): Route | undefined;
+    /** Match the request, bind parameters, run the route middleware and the action. Called by the Http kernel. */
+    dispatch(request: HttpRequest): Promise<Response>;
 }
 declare const Router: Token<Router>;
 /**
@@ -360,6 +831,36 @@ interface RouteModelResolver {
     resolveExplicit(model: Class<unknown>, value: string, field?: string): Promise<unknown>;
 }
 declare const RouteModelResolver: Token<RouteModelResolver>;
+/**
+ * Route name → parameters, for the typed route() and redirect().route() helpers. Empty until `oriel route:types`
+ * augments it (types/routes.d.ts); while it is empty any string is accepted. The contracts themselves keep taking
+ * strings: the framework builds route names at run time.
+ */
+interface RouteList {
+}
+/** A route name: the generated ones, or any string before `oriel route:types` has run. */
+type RouteName = [keyof RouteList] extends [never] ? string : Extract<keyof RouteList, string>;
+/** A route parameter's value: a scalar, or a model (its route key, or the `{post:slug}` column, goes in the URL). */
+type RouteParameter = string | number | bigint | boolean | {
+    getRouteKey(): unknown;
+};
+type GeneratedParameters<N extends keyof RouteList> = {
+    [K in keyof RouteList[N]]: RouteParameter;
+};
+type RequiredParameters<P> = {
+    [K in keyof P]-?: Record<never, never> extends Pick<P, K> ? never : K;
+}[keyof P];
+/**
+ * A named route's parameters: named (`{ post }`, extra keys become the query string), one value (it fills the first
+ * parameter), or values in URI order (`[post, comment]`).
+ */
+type RouteParameters<N extends string> = N extends keyof RouteList ? (GeneratedParameters<N> & Record<string, unknown>) | RouteParameter | readonly RouteParameter[] : unknown;
+/**
+ * The arguments after a route name in route() and redirect().route(): the parameters, required when the route has a
+ * required one, then `Rest` (route()'s `absolute`, redirect().route()'s `status`). Before `oriel route:types` has
+ * named the route, anything is accepted.
+ */
+type RouteArguments<N extends string, Rest extends unknown[] = [absolute?: boolean]> = N extends keyof RouteList ? [RequiredParameters<RouteList[N]>] extends [never] ? [parameters?: RouteParameters<N>, ...rest: Rest] : [parameters: RouteParameters<N>, ...rest: Rest] : [parameters?: unknown, ...rest: Rest];
 interface UrlGenerator {
     to(path: string, query?: Record<string, unknown>, absolute?: boolean): string;
     route(name: string, parameters?: unknown, absolute?: boolean): string;
@@ -367,21 +868,34 @@ interface UrlGenerator {
     current(): string;
     previous(fallback?: string): string;
     hasRoute(name: string): boolean;
+    /** A URL to a named route with a `signature` query (HMAC-SHA256 keyed by APP_KEY); `expiration` adds `expires`. */
+    signedRoute(name: string, parameters?: unknown, expiration?: Date | number, absolute?: boolean): string;
+    /** signedRoute() that expires: a Date, or seconds from now. */
+    temporarySignedRoute(name: string, expiration: Date | number, parameters?: unknown, absolute?: boolean): string;
+    /** Whether the request URL carries a valid, unexpired signature (`absolute: false` signs the path only). */
+    hasValidSignature(request: HttpRequest, absolute?: boolean): boolean;
 }
 declare const UrlGenerator: Token<UrlGenerator>;
 interface RedirectResponse extends Responsable {
     readonly targetUrl: string;
     with(key: string | Record<string, unknown>, value?: unknown): this;
-    withErrors(errors: Record<string, string | string[]>, bag?: string): this;
+    /** Flashes the errors (a record, or a validator's `errors()`) into the bag, `default` unless named. */
+    withErrors(errors: Record<string, string | string[]> | MessageBag, bag?: string): this;
     withInput(input?: Record<string, unknown>): this;
     withCookie(name: string, value: string, minutes?: number): this;
+    header(name: string, value: string): this;
 }
 interface Redirector {
     to(path: string, status?: number): RedirectResponse;
     route(name: string, parameters?: unknown, status?: number): RedirectResponse;
     back(fallback?: string, status?: number): RedirectResponse;
-    intended(fallback?: string): RedirectResponse;
+    intended(fallback?: string, status?: number): RedirectResponse;
     away(url: string, status?: number): RedirectResponse;
+    /** Remembers the URL a guest was going to (for intended()), then redirects to `path`. */
+    guest(path: string, status?: number): RedirectResponse;
+    /** Redirects to the current URL. */
+    refresh(status?: number): RedirectResponse;
+    setIntendedUrl(url: string): void;
 }
 declare const Redirector: Token<Redirector>;
 
@@ -438,6 +952,8 @@ interface ViewFactory {
     exists(name: string): boolean;
     share(key: string | Record<string, unknown>, value?: unknown): void;
     composer(views: string | string[], composer: (view: View) => void | Promise<void>): void;
+    /** Renders TSX (an element, a string, an Htmlable, a View, promises of them) to HTML, like Blade::render(). */
+    renderToString(node: unknown): Promise<string>;
 }
 declare const ViewFactory: Token<ViewFactory>;
 
@@ -458,10 +974,12 @@ interface Logger {
 interface LogManager extends Logger {
     channel(name?: string): Logger;
     stack(channels: string[]): Logger;
+    /** Writes out and closes the channels opened so far (log files are written asynchronously); a script awaits it last. */
+    flush(): Promise<void>;
 }
 declare const LogManager: Token<LogManager>;
 
-type ErrorKind = 'Http' | 'ModelNotFound' | 'Validation' | 'Authentication' | 'Authorization' | 'TokenMismatch' | 'BindingResolution' | 'CircularDependency' | 'ContainerNotAvailable';
+type ErrorKind = 'Http' | 'Server' | 'ModelNotFound' | 'Validation' | 'Authentication' | 'Authorization' | 'TokenMismatch' | 'BindingResolution' | 'CircularDependency' | 'ContainerNotAvailable';
 /** Every error thrown by the framework implements this. The exception handler switches on `kind`. */
 interface OrielError extends Error {
     readonly kind: ErrorKind;
@@ -513,6 +1031,11 @@ interface QueryBuilder<T = Row> {
     count(): Promise<number>;
     exists(): Promise<boolean>;
     insert(values: Row | Row[]): Promise<void>;
+    /**
+     * Inserts rows, skipping any that violate a unique key instead of failing (Laravel's insertOrIgnore). Returns the
+     * number of rows inserted. Nothing is thrown for a duplicate, so a caller's transaction stays usable on Postgres.
+     */
+    insertOrIgnore(values: Row | Row[]): Promise<number>;
     insertGetId(values: Row, keyName?: string): Promise<number | string>;
     update(values: Row): Promise<number>;
     upsert(values: Row | Row[], uniqueBy: string[], update?: string[]): Promise<number>;
@@ -529,10 +1052,22 @@ interface DatabaseConnection {
     statement(sql: string, bindings?: readonly unknown[]): Promise<void>;
     /** Nested calls use savepoints. Rolls back if fn throws. */
     transaction<R>(fn: (connection: DatabaseConnection) => Promise<R>): Promise<R>;
+    /**
+     * Start a transaction that stays open, for every caller of this connection, until commit()/rollBack().
+     * Nested calls use savepoints. Meant for test isolation (RefreshDatabase); app code uses transaction(fn).
+     */
+    beginTransaction(): Promise<void>;
+    commit(): Promise<void>;
+    /** Rolls back the innermost level opened by beginTransaction(). Does nothing when none is open. */
+    rollBack(): Promise<void>;
+    /** 0 outside a transaction. */
+    transactionLevel(): number;
 }
 interface DatabaseManager extends DatabaseConnection {
     connection(name?: string): DatabaseConnection;
     disconnect(name?: string): Promise<void>;
+    /** Closes every open connection and forgets them (the application's shutdown, the end of a test). */
+    disconnectAll(): Promise<void>;
 }
 declare const DatabaseManager: Token<DatabaseManager>;
 /** What non-Database components may rely on from a model instance. */
@@ -543,6 +1078,8 @@ interface ModelInstance {
     getTable(): string;
     getRouteKey(): unknown;
     getRouteKeyName(): string;
+    /** The value stored in a polymorphic `*_type` column for this model: its morph map alias, else its class name. */
+    getMorphClass(): string;
     getAttribute<T = unknown>(key: string): T;
     setAttribute(key: string, value: unknown): this;
     fill(attributes: Row): this;
@@ -558,38 +1095,19 @@ interface ModelStatic<M extends ModelInstance = ModelInstance> {
     find(id: unknown): Promise<M | undefined>;
     findOrFail(id: unknown): Promise<M>;
 }
-
-/** A rule object (Laravel's ValidationRule). Call fail() to reject the value. */
-interface ValidationRule {
-    validate(attribute: string, value: unknown, fail: (message: string) => void, data: Record<string, unknown>): void | Promise<void>;
-}
-/** 'required|string|max:255', or an array mixing strings and rule objects. Keys support dot + `*` wildcards. */
-type Rules = Record<string, string | ReadonlyArray<string | ValidationRule>>;
-interface MessageBag {
-    has(key: string): boolean;
-    first(key?: string): string | undefined;
-    get(key: string): string[];
-    all(): string[];
-    isEmpty(): boolean;
-    count(): number;
-    toObject(): Record<string, string[]>;
-}
-interface Validator {
-    passes(): Promise<boolean>;
-    fails(): Promise<boolean>;
-    /** Only the keys that have rules. Throws ValidationError (Exceptions.ts) on failure. */
-    validated<T = Record<string, unknown>>(): Promise<T>;
-    /** Valid only after passes()/fails()/validated() has run. */
-    errors(): MessageBag;
-    after(callback: (validator: Validator) => void | Promise<void>): this;
-}
-type RuleCallback = (attribute: string, value: unknown, parameters: string[], data: Record<string, unknown>) => boolean | Promise<boolean>;
-interface ValidationFactory {
-    make(data: Record<string, unknown>, rules: Rules, messages?: Record<string, string>, attributes?: Record<string, string>): Validator;
-    /** Registers a string rule, e.g. extend('uppercase', fn, ':attribute must be uppercase'). */
-    extend(name: string, callback: RuleCallback, message?: string): void;
+/**
+ * What decides a paginator's page and the path of its links when the request doesn't (Laravel's
+ * Paginator::currentPageResolver and currentPathResolver, which Livewire's WithPagination replaces). Live binds one for
+ * the application, which answers while a WithPagination component mounts, runs an update's hooks and actions, or
+ * renders. Unbound, or `undefined` from a method, the paginators read the request (`?page=` and its URL).
+ */
+interface PaginationState {
+    /** The page to show for `pageName` ('page' by default). */
+    currentPage(pageName: string): number | undefined;
+    /** The base path of the page links. */
+    currentPath(): string | undefined;
 }
-declare const ValidationFactory: Token<ValidationFactory>;
+declare const PaginationState: Token<PaginationState>;
 
 interface Authenticatable {
     getAuthIdentifierName(): string;
@@ -658,6 +1176,11 @@ interface MustVerifyEmail {
 
 /** Options a job class may declare as public fields. Their presence (or implementing ShouldQueue) makes things queueable. */
 interface ShouldQueue {
+    /**
+     * Marks the class as queued at run time: `implements ShouldQueue` leaves no trace once compiled, so the interface
+     * asks for `readonly shouldQueue = true`. Jobs, listeners, mailables and notifications carrying it are queued.
+     */
+    readonly shouldQueue: true;
     connection?: string;
     queue?: string;
     /** Seconds. */
@@ -667,7 +1190,11 @@ interface ShouldQueue {
     backoff?: number | number[];
     /** Seconds. */
     timeout?: number;
-    uniqueId?(): string;
+    /**
+     * Laravel's ShouldBeUnique: while a job with this id is pending, another one is dropped. A queued listener's
+     * receives the event (Laravel 13); a number is used as its string.
+     */
+    uniqueId?(...args: never[]): string | number;
 }
 /** A job: public fields are its serialized data; handle() runs on the worker (inject() works inside it). */
 interface Job extends Partial<ShouldQueue> {
@@ -688,6 +1215,10 @@ interface QueuePayload {
     pushedAt: number;
     batchId?: string;
     chain?: QueuePayload[];
+    /** Unix ms after which the job fails instead of retrying. */
+    retryUntil?: number;
+    /** Mark the job failed (instead of releasing it) when it times out. */
+    failOnTimeout?: boolean;
 }
 interface QueueJob {
     getJobId(): string;
@@ -770,6 +1301,31 @@ interface BusDispatcher {
     findBatch(id: string): Promise<Batch | undefined>;
 }
 declare const BusDispatcher: Token<BusDispatcher>;
+/** What PendingBatch hands to the repository. Callbacks are jobs, because closures can't be serialized. */
+interface PendingBatchOptions {
+    name: string;
+    then: Job[];
+    catch: Job[];
+    finally: Job[];
+    allowFailures: boolean;
+    connection?: string;
+    queue?: string;
+}
+/** Stores batches and runs their bookkeeping (Laravel's BatchRepository). Bound by the Queue component. */
+interface BatchRepository {
+    store(options: PendingBatchOptions): Promise<Batch>;
+    find(id: string): Promise<Batch | undefined>;
+    /** Adds `amount` to both total and pending jobs, before the jobs are pushed. */
+    incrementTotalJobs(id: string, amount: number): Promise<void>;
+    /** A batched job succeeded: decrement pending, then run then/finally callbacks when due. */
+    recordSuccessfulJob(id: string, jobUuid: string): Promise<void>;
+    /** A batched job failed for good: count it, cancel unless failures are allowed, run catch/finally when due. */
+    recordFailedJob(id: string, jobUuid: string, error: unknown): Promise<void>;
+    markAsFinished(id: string): Promise<void>;
+    cancel(id: string): Promise<void>;
+    delete(id: string): Promise<void>;
+}
+declare const BatchRepository: Token<BatchRepository>;
 
 /** A CLI command. Signature uses Laravel syntax: 'mail:send {user} {--queue=default}'. */
 interface Command {
@@ -777,6 +1333,29 @@ interface Command {
     readonly description: string;
     handle(): number | void | Promise<number | void>;
 }
+type OptionValue = string | boolean | string[] | undefined;
+/** `this` inside a closure command (Laravel's Command API). */
+interface CommandContext extends Command {
+    argument(name: string): string | string[] | undefined;
+    arguments(): Record<string, string | string[]>;
+    option(name: string): OptionValue;
+    options(): Record<string, OptionValue>;
+    info(message: string): void;
+    line(message?: string): void;
+    comment(message: string): void;
+    warn(message: string): void;
+    error(message: string): void;
+    newLine(count?: number): void;
+    table(headers: string[], rows: string[][]): void;
+    ask(question: string, defaultValue?: string): Promise<string>;
+    secret(question: string): Promise<string>;
+    confirm(question: string, defaultValue?: boolean): Promise<boolean>;
+    choice(question: string, choices: string[], defaultIndex?: number): Promise<string>;
+}
+/** What ConsoleKernel.command() returns. */
+interface ClosureCommand extends CommandContext {
+    purpose(description: string): this;
+}
 interface ConsoleKernel {
     /** Returns the exit code. */
     handle(argv: string[]): Promise<number>;
@@ -784,29 +1363,89 @@ interface ConsoleKernel {
     /** Output buffered from the last call(). */
     output(): string;
     all(): Record<string, Command>;
+    /** Register command classes or instances (components call this from their provider's boot()). */
+    register(...commands: Array<Command | (new () => Command)>): void;
+    /** Closure command, like Artisan::command() in routes/console.ts. `this` is the command (argument(), info(), …). */
+    command(signature: string, handler: (this: CommandContext, ...args: unknown[]) => number | void | Promise<number | void>): ClosureCommand;
 }
 declare const ConsoleKernel: Token<ConsoleKernel>;
+/** A callback a scheduled event runs before or after itself (before(), after(), onSuccess(), onFailure()). */
+type ScheduleHook = () => unknown;
 interface ScheduledEvent {
     readonly expression: string;
+    /**
+     * What a Schedule.command() event runs: the command and its parameters ('posts:announce --force'), without the
+     * runtime and `oriel` in front. Undefined for call() and job() events. Laravel's `$event->command`.
+     */
+    readonly command: string | undefined;
+    /** Whether withoutOverlapping() was called. Laravel's `$event->withoutOverlapping`, a method's name here. */
+    readonly preventsOverlapping: boolean;
+    /** Minutes the withoutOverlapping() lock is kept at most (1440 unless withoutOverlapping() says). Laravel's `$event->expiresAt`. */
+    readonly expiresAt: number;
     cron(expression: string): this;
+    /**
+     * Runs every N seconds: the event is due every minute, and schedule:run (or schedule:work) keeps running it until
+     * the minute ends. N divides 60.
+     */
+    everySecond(): this;
+    everyTwoSeconds(): this;
+    everyFiveSeconds(): this;
+    everyTenSeconds(): this;
+    everyFifteenSeconds(): this;
+    everyTwentySeconds(): this;
+    everyThirtySeconds(): this;
     everyMinute(): this;
+    everyTwoMinutes(): this;
+    everyThreeMinutes(): this;
+    everyFourMinutes(): this;
     everyFiveMinutes(): this;
+    everyTenMinutes(): this;
     everyFifteenMinutes(): this;
     everyThirtyMinutes(): this;
     hourly(): this;
-    hourlyAt(minute: number): this;
+    /** At these minutes past every hour. */
+    hourlyAt(minute: number | readonly number[]): this;
+    /** Every odd hour (1, 3, … 23), at `minute` past (0 by default). */
+    everyOddHour(minute?: number | readonly number[]): this;
+    everyTwoHours(minute?: number | readonly number[]): this;
+    everyThreeHours(minute?: number | readonly number[]): this;
+    everyFourHours(minute?: number | readonly number[]): this;
+    everySixHours(minute?: number | readonly number[]): this;
     daily(): this;
+    /** The same as dailyAt(). */
+    at(time: string): this;
     dailyAt(time: string): this;
     twiceDaily(first?: number, second?: number): this;
+    /** At hours `first` and `second`, `minute` past. */
+    twiceDailyAt(first?: number, second?: number, minute?: number): this;
+    weekdays(): this;
+    weekends(): this;
+    mondays(): this;
+    tuesdays(): this;
+    wednesdays(): this;
+    thursdays(): this;
+    fridays(): this;
+    saturdays(): this;
+    sundays(): this;
     weekly(): this;
-    weeklyOn(day: number, time?: string): this;
+    /** On these days of the week (0 = Sunday … 6 = Saturday), at `time` ('0:0' by default). */
+    weeklyOn(day: number | readonly number[], time?: string): this;
     monthly(): this;
-    monthlyOn(day: number, time?: string): this;
+    monthlyOn(day?: number, time?: string): this;
+    twiceMonthly(first?: number, second?: number, time?: string): this;
+    /** On the last day of every month, at `time`. */
+    lastDayOfMonth(time?: string): this;
+    quarterly(): this;
+    /** On day `day` of the first month of each quarter, at `time`. */
+    quarterlyOn(day?: number, time?: string): this;
     yearly(): this;
-    weekdays(): this;
-    weekends(): this;
+    yearlyOn(month?: number, day?: number, time?: string): this;
+    /** On these days of the week (0 = Sunday … 6 = Saturday): `days([1, 3])` or `days(1, 3)`. */
+    days(days: number | readonly number[], ...more: number[]): this;
     timezone(timezone: string): this;
     between(start: string, end: string): this;
+    /** Skips the event between these times (a window may cross midnight: '23:00', '4:00'). */
+    unlessBetween(start: string, end: string): this;
     when(callback: () => boolean | Promise<boolean>): this;
     skip(callback: () => boolean | Promise<boolean>): this;
     /** Uses a cache lock (default 1440 minutes). */
@@ -816,6 +1455,22 @@ interface ScheduledEvent {
     runInBackground(): this;
     name(name: string): this;
     description(description: string): this;
+    /** Runs before the event, once its filters and locks let it run. */
+    before(callback: ScheduleHook): this;
+    /** Runs after the event, whether it succeeded or failed (also then()). */
+    after(callback: ScheduleHook): this;
+    then(callback: ScheduleHook): this;
+    /** Runs after the event when it succeeded: a command exited 0, a closure neither threw nor returned false. */
+    onSuccess(callback: ScheduleHook): this;
+    /** Runs after the event when it failed: a command exited non-zero, a closure threw or returned false. */
+    onFailure(callback: ScheduleHook): this;
+    /** The name, else the description: the command, the job's class, or 'Closure'. schedule:list shows it. */
+    getSummaryForDisplay(): string;
+    /**
+     * The cache lock withoutOverlapping() holds: `framework/schedule-` and the sha1 of the expression and the command,
+     * or of the name for call() and job() events (Laravel's mutexName()). schedule:clear-cache deletes it.
+     */
+    mutexName(): string;
     isDue(now: Date): boolean;
     run(): Promise<void>;
 }
@@ -854,6 +1509,8 @@ interface Content {
     text?: string;
     /** Raw HTML (used when no view is given). */
     htmlString?: string;
+    /** Raw plain-text body (used when no text view is given). */
+    textString?: string;
     with?: Record<string, unknown>;
 }
 interface Attachment {
@@ -892,6 +1549,8 @@ interface PendingMail {
     cc(recipients: MailRecipient | MailRecipient[]): this;
     bcc(recipients: MailRecipient | MailRecipient[]): this;
     send(mailable: Mailable): Promise<SentMessage | undefined>;
+    /** Sends at once, even when the mailable is queueable (Laravel's sendNow()). A fake resolves undefined. */
+    sendNow(mailable: Mailable): Promise<SentMessage | undefined>;
     queue(mailable: Mailable): Promise<void>;
     later(delaySeconds: number, mailable: Mailable): Promise<void>;
 }
@@ -899,6 +1558,8 @@ interface Mailer {
     to(recipients: MailRecipient | MailRecipient[]): PendingMail;
     /** Sends to the recipients given in the mailable's envelope. Queues it if the mailable is queueable. */
     send(mailable: Mailable): Promise<SentMessage | undefined>;
+    /** Sends to the envelope's recipients at once, even when the mailable is queueable (Laravel's sendNow()). */
+    sendNow(mailable: Mailable): Promise<SentMessage | undefined>;
     queue(mailable: Mailable): Promise<void>;
 }
 interface MailManager extends Mailer {
@@ -934,13 +1595,35 @@ interface NotificationDispatcher {
     extend(channel: string, factory: () => NotificationChannel): void;
 }
 declare const NotificationDispatcher: Token<NotificationDispatcher>;
+/**
+ * A stored database notification (Laravel's DatabaseNotification model): one row of the `notifications` table, with
+ * its snake_case columns. `user.notifications()`, `unreadNotifications()` and `readNotifications()` query these,
+ * newest first.
+ */
+interface DatabaseNotification extends ModelInstance {
+    /** A UUID. */
+    readonly id: string;
+    /** The notification's class name. */
+    readonly type: string;
+    /** What the notification's toDatabase() (or toArray()) returned. */
+    readonly data: Record<string, unknown>;
+    read_at: Date | null;
+    readonly created_at: Date | null;
+    readonly updated_at: Date | null;
+    /** Sets read_at to now and saves, unless it is already read. */
+    markAsRead(): Promise<void>;
+    /** Clears read_at and saves, unless it is already unread. */
+    markAsUnread(): Promise<void>;
+    read(): boolean;
+    unread(): boolean;
+}
 
 interface Lock {
     /** Tries once. Returns whether it was acquired. */
     get(): Promise<boolean>;
     /** Tries once. Runs the callback and releases if acquired, else returns false. */
     get<T>(callback: () => T | Promise<T>): Promise<T | false>;
-    /** Waits up to `seconds` to acquire. Throws LockTimeout (an OrielError, kind 'Http', status 423) on timeout. */
+    /** Waits up to `seconds` to acquire. Throws LockTimeoutError (an OrielError, kind 'Server', status 500) on timeout. */
     block<T>(seconds: number, callback?: () => T | Promise<T>): Promise<T | true>;
     release(): Promise<boolean>;
     forceRelease(): Promise<void>;
@@ -973,6 +1656,18 @@ interface CacheManager extends CacheRepository {
     extend(driver: string, factory: (config: Record<string, unknown>) => CacheRepository): void;
 }
 declare const CacheManager: Token<CacheManager>;
+/** Laravel's RateLimiter: hits per key, kept in the default cache store. */
+interface RateLimiter {
+    tooManyAttempts(key: string, maxAttempts: number): Promise<boolean>;
+    /** Adds a hit; the window starts at the first hit and lasts `decaySeconds` (default 60). Returns the hit count. */
+    hit(key: string, decaySeconds?: number): Promise<number>;
+    attempts(key: string): Promise<number>;
+    remaining(key: string, maxAttempts: number): Promise<number>;
+    /** Seconds until the key's window resets. */
+    availableIn(key: string): Promise<number>;
+    clear(key: string): Promise<void>;
+}
+declare const RateLimiter: Token<RateLimiter>;
 
 type ListenerClass<E> = Class<{
     handle(event: E): unknown;
@@ -1029,38 +1724,99 @@ interface FilesystemManager extends Filesystem {
 }
 declare const FilesystemManager: Token<FilesystemManager>;
 
-/** The Inertia page object (protocol v2). */
+/** Infinite-scroll metadata for one prop (page.scrollProps[path]). */
+interface InertiaScrollProp {
+    pageName: string;
+    previousPage: string | number | null;
+    nextPage: string | number | null;
+    currentPage: string | number | null;
+    reset: boolean;
+}
+/** A once prop the client keeps between visits (page.onceProps[key]). `expiresAt` is epoch milliseconds. */
+interface InertiaOnceProp {
+    prop: string;
+    expiresAt: number | null;
+}
+/**
+ * The Inertia page object (protocol v3, @inertiajs/core 3.x). Only component, props, url and version are always
+ * present; the other fields are left out when empty or false.
+ */
 interface InertiaPage {
     component: string;
     props: Record<string, unknown>;
+    /** Path and query, never absolute: '/posts?page=2'. */
     url: string;
-    version: string | null;
-    encryptHistory?: boolean;
-    clearHistory?: boolean;
+    /** '' when the app has no asset version. */
+    version: string;
+    sharedProps?: string[];
     mergeProps?: string[];
+    prependProps?: string[];
+    deepMergeProps?: string[];
+    /** '<prop path>.<key field>', e.g. 'posts.data.id'. */
+    matchPropsOn?: string[];
+    /** Group name → prop paths loaded after the first render. */
     deferredProps?: Record<string, string[]>;
+    rescuedProps?: string[];
+    scrollProps?: Record<string, InertiaScrollProp>;
+    onceProps?: Record<string, InertiaOnceProp>;
+    clearHistory?: true;
+    encryptHistory?: true;
+    flash?: Record<string, unknown>;
+    preserveFragment?: true;
 }
 interface InertiaResponse extends Responsable {
     with(key: string | Record<string, unknown>, value?: unknown): this;
     withViewData(key: string | Record<string, unknown>, value?: unknown): this;
+    rootView(view: string): this;
+    /** Flash data for the next page (page.flash), stored in the session. */
+    flash(key: string | Record<string, unknown>, value?: unknown): this;
 }
 type PropCallback<T = unknown> = () => T | Promise<T>;
+/** The SSR result spliced into the root view: the `head` tags and the rendered `body`. */
+interface InertiaSsrResponse {
+    head: string;
+    body: string;
+}
+/** Sends a page to the SSR server. Resolves to undefined when SSR is off, unreachable or failing. */
+interface InertiaSsrGateway {
+    dispatch(page: InertiaPage): Promise<InertiaSsrResponse | undefined>;
+}
+declare const InertiaSsrGateway: Token<InertiaSsrGateway>;
 interface InertiaFactory {
     render(component: string, props?: Record<string, unknown>): InertiaResponse;
     share(key: string | Record<string, unknown>, value?: unknown): void;
+    /** A shared once prop: sent on the first visit, then kept by the client. */
+    shareOnce(key: string, callback: PropCallback): void;
     getShared(key?: string): unknown;
-    version(version: string | (() => string | Promise<string>)): void;
+    flushShared(): void;
+    version(version: string | null | (() => string | null | Promise<string | null>)): void;
+    getVersion(): Promise<string>;
+    setRootView(view: string): void;
     /** Only evaluated on partial reloads that ask for it. */
     optional<T>(callback: PropCallback<T>): unknown;
     /** Loaded in a follow-up request after the first render. */
     defer<T>(callback: PropCallback<T>, group?: string): unknown;
     /** Always included, even in partial reloads. */
     always<T>(value: T | PropCallback<T>): unknown;
-    /** Merged with the existing client-side value instead of replacing it. */
+    /** Appended to the existing client-side value instead of replacing it. */
     merge<T>(value: T | PropCallback<T>): unknown;
-    /** 409 + X-Inertia-Location for external redirects. */
+    /** Deep-merged with the existing client-side value. */
+    deepMerge<T>(value: T | PropCallback<T>): unknown;
+    /** Resolved once, then remembered by the client. */
+    once<T>(callback: PropCallback<T>): unknown;
+    /** Infinite scroll over a paginator: merged page by page, with scroll metadata. */
+    scroll<T>(value: T | PropCallback<T>, wrapper?: string): unknown;
+    /** Flash data for the next page (page.flash), stored in the session. */
+    flash(key: string | Record<string, unknown>, value?: unknown): this;
+    encryptHistory(encrypt?: boolean): void;
+    /** The next page tells the client to clear its encrypted history. */
+    clearHistory(): void;
+    /** The next page keeps the URL fragment of the request that redirected to it. */
+    preserveFragment(): void;
+    /** 409 + X-Inertia-Location for Inertia requests, a plain 302 otherwise. */
     location(url: string): Response;
-    setRootView(view: string): void;
+    /** Redirect back (Inertia.flash('saved', true).back()). */
+    back(fallback?: string, status?: number): RedirectResponse;
 }
 declare const InertiaFactory: Token<InertiaFactory>;
 
@@ -1080,11 +1836,18 @@ interface LiveSnapshot {
 }
 interface LiveEffects {
     html?: string;
+    /** Browser events from this.dispatch(); `self` keeps one on this component, `to` sends it to one component name. */
     dispatches?: Array<{
         name: string;
-        params: unknown[];
+        params: Record<string, unknown>;
+        self?: true;
+        to?: string;
     }>;
+    /** Events this component listens to (@On, static listeners); sent with the first render. */
+    listeners?: string[];
     redirect?: string;
+    /** Follow `redirect` with o:navigate instead of a full page load. */
+    redirectUsingNavigate?: true;
     returns?: unknown[];
 }
 interface LiveUpdateRequest {
@@ -1106,12 +1869,17 @@ interface LiveUpdateResponse {
 }
 interface LiveManager {
     register(component: Class<unknown>, name?: string): void;
-    /** Server-renders the first HTML (snapshot embedded). */
-    mount(component: string | Class<unknown>, params?: Record<string, unknown>): Promise<string>;
+    /** Server-renders the first HTML (snapshot embedded). `key` identifies a child inside its parent (o:key). */
+    mount(component: string | Class<unknown>, params?: Record<string, unknown>, key?: string): Promise<string>;
     /** Checks checksums and CSRF, then applies updates and calls, re-renders and returns new snapshots. */
     update(request: LiveUpdateRequest): Promise<LiveUpdateResponse>;
+    /**
+     * A full-page component (Route.get('/counter', Counter)): mounts `component` (a component instance) with the current route's parameters and
+     * returns the response, its layout view or a redirect.
+     */
+    page(component: object): Promise<unknown>;
     isLiveRequest(request: HttpRequest): boolean;
 }
 declare const LiveManager: Token<LiveManager>;
 
-export { type AbilityCallback, type Abstract, type ActionMethods, type Address, Application, type Arrayable, type Attachment, AuthFactory, type Authenticatable, type AuthenticationError, type Batch, type BodyInit, BusDispatcher, CacheManager, type CacheRepository, type Class, ClassRegistry, type Command, type Concrete, type ConfigCallbacks, ConfigRepository, ConsoleKernel, Container, type Content, type ControllerAction, type Cookie, CookieJar, type Credentials, type DatabaseConnection, DatabaseManager, type DriverName, Encrypter, type Enumerable, type Envelope, type ErrorKind, EventDispatcher, ExceptionCallbacks, ExceptionHandler, type ExceptionsConfigurator, type Factory, type FailedJob, FailedJobProvider, type Filesystem, FilesystemManager, Gate, type Guard, Hasher, type HeadersInit, type Htmlable, HttpKernel, HttpRequest, InertiaFactory, type InertiaPage, type InertiaResponse, type Job, type Jsonable, type Listener, type ListenerClass, type LiveEffects, LiveManager, type LiveSnapshot, type LiveUpdateRequest, type LiveUpdateResponse, type Lock, type LogLevel, LogManager, type Logger, MailManager, type MailRecipient, type MailTransport, type Mailable, type Mailer, type MessageBag, type Middleware, MiddlewareCallbacks, type MiddlewareClass, type MiddlewareConfigurator, type MiddlewareReference, type ModelInstance, type ModelNotFoundError, type ModelStatic, type MustVerifyEmail, type Next, type Notifiable, type Notification, type NotificationChannel, NotificationDispatcher, type Operator, type OrielError, type OutgoingMessage, PasswordBroker, type PasswordStatus, type PendingBatch, type PendingChain, type PendingMail, type Pipe, type PipeClosure, type PipeNext, type Pipeline, PipelineFactory, type PropCallback, type PutOptions, type QueryBuilder, type Queue, type QueueJob, QueueManager, type QueuePayload, type RedirectResponse, Redirector, type ResourceOptions, type Responsable, ResponseFactory, type Route, type RouteAction, type RouteClosure, RouteModelResolver, type RouteRegistrar, Router, RoutingPaths, type Row, type RuleCallback, type Rules, Schedule, type ScheduledEvent, type SentMessage, type ServiceProvider, type ServiceProviderClass, Session, type SessionHandler, type ShouldQueue, type StatefulGuard, type Token, type UploadedFile, UrlGenerator, type UserProvider, type ValidationError, ValidationFactory, type ValidationRule, type Validator, type View, ViewFactory, token };
+export { type AbilityCallback, type Abstract, type ActionMethods, type Address, Application, type Arrayable, type Attachment, AuthFactory, type Authenticatable, type AuthenticationError, type Batch, BatchRepository, type BodyInit, BusDispatcher, CacheManager, type CacheRepository, type Class, ClassRegistry, type ClosureCommand, type Command, type CommandContext, type Concrete, type ConfigCallbacks, ConfigRepository, ConsoleKernel, Container, type Content, type ControllerAction, type Cookie, CookieJar, type Credentials, CurrentRoute, type DatabaseConnection, DatabaseManager, type DatabaseNotification, type DriverName, Encrypter, type Enumerable, type Envelope, type ErrorKind, EventDispatcher, ExceptionCallbacks, ExceptionHandler, type ExceptionsConfigurator, type Factory, type FailedJob, FailedJobProvider, type Filesystem, FilesystemManager, Gate, type Guard, Hasher, type HeadersInit, type Htmlable, HttpKernel, HttpRequest, type InValue, InertiaFactory, type InertiaOnceProp, type InertiaPage, type InertiaResponse, type InertiaScrollProp, InertiaSsrGateway, type InertiaSsrResponse, type InferRuleType, type InferValidatedType, type InvokableClass, type Job, type Jsonable, type Listener, type ListenerClass, type LiveEffects, LiveManager, type LiveSnapshot, type LiveUpdateRequest, type LiveUpdateResponse, type Lock, type LogLevel, LogManager, type Logger, MailManager, type MailRecipient, type MailTransport, type Mailable, type Mailer, type MessageBag, type Middleware, MiddlewareCallbacks, type MiddlewareClass, type MiddlewareConfigurator, type MiddlewareReference, type ModelInstance, type ModelNotFoundError, type ModelStatic, type MustVerifyEmail, type Next, type Notifiable, type Notification, type NotificationChannel, NotificationDispatcher, type NumericValue, type Operator, type OptionValue, type OrielError, type OutgoingMessage, PaginationState, PasswordBroker, type PasswordStatus, type PendingBatch, type PendingBatchOptions, type PendingChain, type PendingMail, type Pipe, type PipeClosure, type PipeNext, type Pipeline, PipelineFactory, type PropCallback, type PutOptions, type QueryBuilder, type Queue, type QueueJob, QueueManager, type QueuePayload, RateLimiter, type RedirectResponse, Redirector, type ResourceOptions, type Responsable, ResponseFactory, type Route, type RouteAction, type RouteArguments, type RouteClosure, type RouteList, RouteModelResolver, type RouteName, type RouteParameter, type RouteParameters, type RouteRegistrar, Router, RoutingPaths, type Row, type RuleCallback, type RuleParameterList, type RuleTyping, type Rules, Schedule, type ScheduleHook, type ScheduledEvent, type SentMessage, type ServiceProvider, type ServiceProviderClass, Session, type SessionHandler, type ShouldQueue, type StatefulGuard, type Token, type TypedValidationRule, type UploadedFile, UrlGenerator, type UserProvider, type ValidationError, ValidationFactory, type ValidationRule, type ValidationRuleTypes, type Validator, type View, ViewFactory, token };