@orieljs/framework 0.1.0-alpha.6 → 0.1.0-alpha.8

package/dist/index.d.ts

@@ -1,17 +1,17 @@
-import { Container as Container$1, Factory as Factory$1, Abstract, Concrete, OrielError, ConfigRepository, Application as Application$2, ServiceProvider, ServiceProviderClass, MiddlewareConfigurator, ExceptionsConfigurator, HttpKernel, Htmlable, Notifiable as Notifiable$1, Notification as Notification$2, NotificationChannel, MailRecipient, NotificationDispatcher, Job, BusDispatcher, EventDispatcher, MailManager as MailManager$1, QueueManager as QueueManager$1, FilesystemManager as FilesystemManager$1, Pipeline, Class, PipeClosure, Pipe, PipelineFactory, Router, ControllerAction, RouteClosure, InvokableClass, Route as Route$1, RouteAction, MiddlewareReference, ResourceOptions, RouteRegistrar, MiddlewareClass, HttpRequest, UrlGenerator, ModelNotFoundError as ModelNotFoundError$1, Middleware, Next as Next$1, ExceptionHandler, UploadedFile, RedirectResponse, HeadersInit, Redirector, ResponseFactory as ResponseFactory$1, BodyInit, Session, Rules, RouteName, CookieJar as CookieJar$1, ConsoleKernel, CommandContext, OptionValue, ClosureCommand as ClosureCommand$1, Command as Command$1, Schedule as Schedule$1, ScheduledEvent, Row, ModelInstance, QueryBuilder, DatabaseConnection, DriverName, Operator, DatabaseManager, DatabaseNotification as DatabaseNotification$1, RouteModelResolver, Token, ValidationRule, MessageBag, ValidationError, ValidationFactory, Validator as Validator$1, RuleCallback, Encrypter as Encrypter$1, Hasher, Cookie as Cookie$1, SessionHandler, Gate as Gate$1, Authenticatable, AbilityCallback, Credentials, AuthFactory, StatefulGuard, Guard, UserProvider, ModelStatic, AuthenticationError as AuthenticationError$1, PasswordBroker as PasswordBroker$1, PasswordStatus, MustVerifyEmail, Logger, LogLevel, ErrorKind, LogManager as LogManager$1, ListenerClass, Listener as Listener$1, ClassRegistry, CacheManager as CacheManager$1, CacheRepository, Lock, RateLimiter as RateLimiter$1, Filesystem, PutOptions, QueueJob, QueuePayload, Batch as Batch$1, BatchRepository, PendingBatchOptions, FailedJobProvider, FailedJob, Queue as Queue$1, PendingChain as PendingChain$1, PendingBatch as PendingBatch$1, ShouldQueue, MailTransport, OutgoingMessage, SentMessage, Mailer, Address, Mailable as Mailable$1, PendingMail, Attachment, Envelope, Content, PropCallback, InertiaFactory, InertiaResponse, InertiaPage, InertiaScrollProp, InertiaOnceProp, InertiaSsrGateway, InertiaSsrResponse } from './contracts.js';
-export { RouteList } from './contracts.js';
-import { F as Facade, S as ServiceProvider$1, f as fileType, a as Stringable, C as Collection, L as LazyCollection } from './index.d-BJyJx6U1.js';
-export { A as Arr, b as ClassRegistry, c as FacadeStatics, d as Str, _ as __, e as app, g as collect, h as config, i as facade, n as now, r as retry, t as tap, v as value } from './index.d-BJyJx6U1.js';
-import { B as BusFake, E as EventFake, M as MailFake, N as NotificationFake, Q as QueueFake, S as StorageFake } from './testing-BM481Hdz.js';
-export { C as Component, a as ComponentResult, b as Computed, c as CorruptComponentPayloadError, d as ErrorBag, I as InvalidLiveRequestError, L as Live, e as LiveComponentManager, f as LiveComponentNotFoundError, g as LiveError, h as LiveProps, i as LiveServiceProvider, j as Locked, k as MethodNotCallableError, O as On, P as PERSISTENT_MIDDLEWARE, l as Paginated, m as Pagination, n as PaginationProps, o as PaginationSource, p as PendingEvent, q as PersistentMiddleware, r as PropertyNotUpdatableError, T as TestRequestScope, s as Testable, U as UPDATE_URI, W as WithPagination, t as componentName, u as live, v as persistentMiddleware } from './testing-BM481Hdz.js';
+import { Container as Container$1, Factory as Factory$1, Abstract, Concrete, OrielError, ConfigRepository, Application as Application$2, ServiceProvider, ServiceProviderClass, MiddlewareConfigurator, ExceptionsConfigurator, HttpKernel, Htmlable, Notifiable as Notifiable$1, Notification as Notification$2, NotificationChannel, MailRecipient, Attachment, NotificationDispatcher, Job, BusDispatcher, EventDispatcher, MailManager as MailManager$1, QueueManager as QueueManager$1, FilesystemManager as FilesystemManager$1, Pipeline, Class, PipeClosure, Pipe, PipelineFactory, Router, ControllerAction, RouteClosure, InvokableClass, Route as Route$1, RouteAction, MiddlewareReference, ResourceOptions, RouteRegistrar, MiddlewareClass, HttpRequest, UrlGenerator, ModelNotFoundError as ModelNotFoundError$1, Middleware, Next as Next$1, ExceptionHandler, UploadedFile, RedirectResponse, HeadersInit, MessageBag, Redirector, ResponseFactory as ResponseFactory$1, BodyInit, Session, Rules, InferValidatedType, RouteName, RouteArguments, CookieJar as CookieJar$1, ConsoleKernel, CommandContext, OptionValue, ClosureCommand as ClosureCommand$1, Command as Command$1, Schedule as Schedule$1, ScheduledEvent, ScheduleHook, Row, ModelInstance, QueryBuilder, DatabaseConnection, DriverName, Operator, DatabaseManager, DatabaseNotification as DatabaseNotification$1, RouteModelResolver, Token, RuleTyping, TypedValidationRule, ValidationRule, InValue, ValidationError, ValidationFactory, Validator as Validator$1, RuleCallback, Encrypter as Encrypter$1, Hasher, Cookie as Cookie$1, SessionHandler, Gate as Gate$1, Authenticatable, AbilityCallback, Credentials, AuthFactory, StatefulGuard, Guard, UserProvider, ModelStatic, AuthenticationError as AuthenticationError$1, PasswordBroker as PasswordBroker$1, PasswordStatus, MustVerifyEmail, Logger, LogLevel, ErrorKind, LogManager as LogManager$1, ListenerClass, Listener as Listener$1, ClassRegistry, CacheManager as CacheManager$1, CacheRepository, Lock, RateLimiter as RateLimiter$1, Filesystem, PutOptions, QueueJob, QueuePayload, Batch as Batch$1, BatchRepository, PendingBatchOptions, FailedJobProvider, FailedJob, Queue as Queue$1, PendingChain as PendingChain$1, PendingBatch as PendingBatch$1, ShouldQueue, MailTransport, OutgoingMessage, SentMessage, Mailer, Address, Mailable as Mailable$1, PendingMail, Envelope, Content, PropCallback, InertiaFactory, InertiaResponse, InertiaPage, InertiaScrollProp, InertiaOnceProp, InertiaSsrGateway, InertiaSsrResponse } from './contracts.js';
+export { InferRuleType, RouteList, RouteParameter, RouteParameters } from './contracts.js';
+import { F as Facade, S as ServiceProvider$1, f as fileType, a as Stringable, C as Collection, L as LazyCollection, O as Operator$1 } from './index.d-WQpfdIbG.js';
+export { A as Arr, b as ClassRegistry, c as FacadeStatics, I as ItemNotFoundError, M as MultipleItemsFoundError, d as Str, _ as __, e as app, g as collect, h as config, i as facade, n as now, r as retry, t as tap, v as value } from './index.d-WQpfdIbG.js';
+import { B as BusFake, E as EventFake, M as MailFake, N as NotificationFake, Q as QueueFake, S as StorageFake } from './testing-CKwfWJGn.js';
+export { C as Component, a as ComponentResult, b as Computed, c as CorruptComponentPayloadError, d as ErrorBag, F as FileNotPreviewableError, I as InvalidLiveRequestError, e as InvalidUploadSignatureError, L as Live, f as LiveComponentManager, g as LiveComponentNotFoundError, h as LiveError, i as LiveProps, j as LiveServiceProvider, k as Locked, l as MethodNotCallableError, O as On, P as PERSISTENT_MIDDLEWARE, m as PREVIEW_URI, n as Paginated, o as Pagination, p as PaginationProps, q as PaginationSource, r as PendingEvent, s as PersistentMiddleware, t as PropertyNotUpdatableError, T as TEMPORARY_UPLOAD_DEFAULTS, u as TemporaryFileData, v as TemporaryFileNotFoundError, w as TemporaryUploadedFile, x as TestRequestScope, y as Testable, U as UPDATE_URI, z as UPLOAD_URI, A as UploadValidationError, W as WithFileUploads, D as WithPagination, G as componentName, H as live, J as persistentMiddleware } from './testing-CKwfWJGn.js';
 import { IncomingMessage, ServerResponse } from 'node:http';
+import { SpawnOptions, ChildProcess } from 'node:child_process';
 import { Kysely, RawBuilder, CompiledQuery, QueryResult, SqliteDatabase, SqliteStatement, Dialect } from 'kysely';
 import Redis$1, { Redis } from 'ioredis';
 import pino from 'pino';
 import { WriteStream } from 'node:fs';
 import { Writable } from 'node:stream';
-import { SpawnOptions, ChildProcess } from 'node:child_process';
-export { C as ClassValue, E as ELEMENT, F as FileViewFinder, a as Fragment, H as HtmlAttributes, b as HtmlString, I as InvalidViewError, O as OrielElement, P as Props, R as Renderable, S as StyleObject, T as TsxView, V as View, c as ViewComponent, d as ViewEnvironment, e as ViewFactoryImpl, f as ViewNotFoundError, g as ViewRenderError, h as ViewServiceProvider, i as classNames, j as createElement, k as csrfField, l as e, m as isElement, n as isHtmlable, o as methodField, r as raw, p as renderToStream, q as renderToString, s as styleString, v as view } from './jsx-runtime-CBZQYYDS.js';
+export { C as ClassValue, E as ELEMENT, F as FileViewFinder, a as Fragment, H as HtmlAttributes, b as HtmlString, I as InvalidViewError, L as LiveDirectives, c as LiveEvent, O as OrielElement, P as Props, R as Renderable, S as StyleObject, T as TsxView, V as View, d as ViewComponent, e as ViewEnvironment, f as ViewFactoryImpl, g as ViewNotFoundError, h as ViewRenderError, i as ViewServiceProvider, j as classNames, k as createElement, l as csrfField, m as e, n as isElement, o as isHtmlable, p as methodField, r as raw, q as renderToStream, s as renderToString, t as styleString, v as view } from './jsx-runtime-6um4Mwfb.js';
 
 type Key = unknown;
 type Lifetime = 'transient' | 'singleton' | 'scoped';
@@ -71,6 +71,23 @@ declare class ContainerNotAvailableError extends Error implements OrielError {
 declare function currentContainer(): Container$1 | undefined;
 declare function inject<T>(abstract: Abstract<T>): T;
 
+/**
+ * Laravel's Config facade: the bound ConfigRepository (`get`, `set`, `has`, `push`, `all`), with Laravel 12's
+ * `prepend()`, `getMany()` and typed getters (`string()`, `integer()`, `float()`, `boolean()`, `array()`). A float is
+ * any number (JavaScript has one number type); an array is a list or an object (a config section).
+ */
+declare const Config: Facade<ConfigRepository, {
+    /** Several keys at once: a list of keys, or an object of keys and their defaults. */
+    getMany(this: ConfigRepository, keys: readonly string[] | Readonly<Record<string, unknown>>): Record<string, unknown>;
+    /** Puts a value first in the array at `key` (creating it when missing). */
+    prepend(this: ConfigRepository, key: string, value: unknown): void;
+    string(this: ConfigRepository, key: string, defaultValue?: string): string;
+    integer(this: ConfigRepository, key: string, defaultValue?: number): number;
+    float(this: ConfigRepository, key: string, defaultValue?: number): number;
+    boolean(this: ConfigRepository, key: string, defaultValue?: boolean): boolean;
+    array(this: ConfigRepository, key: string, defaultValue?: unknown[] | Record<string, unknown>): unknown[] | Record<string, unknown>;
+}>;
+
 declare class Repository$1 implements ConfigRepository {
     private readonly items;
     constructor(items?: Record<string, unknown>);
@@ -113,11 +130,13 @@ declare class ApplicationBuilder {
 type LifecycleCallback = (app: Application$2) => void | Promise<void>;
 declare class Application$1 extends Container implements Application$2 {
     private readonly base;
-    readonly version = "0.1.0-alpha.6";
+    readonly version = "0.1.0-alpha.8";
     private readonly providers;
     private readonly bootingCallbacks;
     private readonly bootedCallbacks;
     private readonly terminatingCallbacks;
+    private readonly shutdownCallbacks;
+    private shutdownPromise;
     private bootPromise;
     private hasBooted;
     private inConsole;
@@ -151,6 +170,20 @@ declare class Application$1 extends Container implements Application$2 {
     terminating(callback: () => void | Promise<void>): void;
     handle(request: Request): Promise<Response>;
     terminate(): Promise<void>;
+    /**
+     * A callback for the end of the process (the CLI after its command, the server on SIGTERM): close DB pools, Redis
+     * clients and log files. Not in Laravel, whose PHP processes end with each request.
+     */
+    onShutdown(callback: () => void | Promise<void>): void;
+    /**
+     * Runs the shutdown callbacks once (a second call returns the same promise), newest first: an app's own callbacks
+     * run before the framework closes what they use, then the framework's in the reverse of its providers' order (the
+     * queue, database and cache connections close, then the log is written, then the session store closes). A failing
+     * callback is printed with console.error (the log may be closed already) and the others still run; after 10 seconds
+     * the rest are given up on, so the process can still exit. Never rejects.
+     */
+    shutdown(): Promise<void>;
+    private runShutdown;
     private runBoot;
     private bootProvider;
 }
@@ -313,16 +346,40 @@ declare class NotificationDispatcherUnavailableError extends Error implements Or
     constructor();
 }
 
+/*!
+ * Laravel's default notification mail (the `notifications::email` view in the `mail::` markdown components with the
+ * `default` theme), as Laravel 12 sends it: the same HTML, with the theme's CSS inlined as CssToInlineStyles inlines
+ * it, and the same plain-text part. The lines are plain text (escaped), not Markdown.
+ *
+ * laravel/framework: Copyright (c) Taylor Otwell
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+ * documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+ * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+type MailLevel = 'info' | 'success' | 'error';
+
 interface MailMessageAction {
     text: string;
     url: string;
 }
 /**
- * Laravel's Illuminate\Notifications\Messages\MailMessage: greeting/line/action/salutation, rendered to a default
- * HTML+text template with no View involved. line() appends to the intro before action() is called, and to the
- * outro afterwards — exactly like Laravel's SimpleMessage.
+ * Laravel's Illuminate\Notifications\Messages\MailMessage: greeting/line/action/salutation, rendered to Laravel's
+ * default notification mail (HTML and text) with no View involved. line() appends to the intro before action() is
+ * called, and to the outro afterwards — exactly like Laravel's SimpleMessage.
  */
 declare class MailMessage {
+    /** info, success or error: the colour of the button, and error() greets with "Whoops!". Laravel's `$level`. */
+    levelName: MailLevel;
     subjectLine?: string;
     greetingLine?: string;
     introLines: string[];
@@ -333,19 +390,40 @@ declare class MailMessage {
     toAddresses: MailRecipient[];
     ccAddresses: MailRecipient[];
     bccAddresses: MailRecipient[];
+    replyToAddresses: MailRecipient[];
     fromAddress?: MailRecipient;
+    attachments: Attachment[];
+    /** A green button: something went well. */
+    success(): this;
+    /** A red button, and "Whoops!" when there is no greeting: something went wrong. */
+    error(): this;
+    level(level: MailLevel): this;
     subject(subject: string): this;
     greeting(greeting: string): this;
     /** Before action(), appends to the intro; after action(), to the outro. */
     line(text: string): this;
     lines(lines: string[]): this;
+    /** line(), when the condition holds. */
+    lineIf(condition: boolean, text: string): this;
+    /** lines(), when the condition holds. */
+    linesIf(condition: boolean, lines: string[]): this;
     action(text: string, url: string): this;
     salutation(salutation: string): this;
     from(address: MailRecipient): this;
     to(recipients: MailRecipient | MailRecipient[]): this;
     cc(recipients: MailRecipient | MailRecipient[]): this;
     bcc(recipients: MailRecipient | MailRecipient[]): this;
-    /** Renders the default notification mail template. No ViewFactory involved. */
+    replyTo(recipients: MailRecipient | MailRecipient[]): this;
+    /** Attaches a file by its path: `as` names it in the mail (its file name by default), `mime` gives its type. */
+    attach(path: string, options?: {
+        as?: string;
+        mime?: string;
+    }): this;
+    /** Attaches bytes or text under a file name. */
+    attachData(data: Uint8Array | string, name: string, options?: {
+        mime?: string;
+    }): this;
+    /** Renders Laravel's default notification mail, HTML and text. No ViewFactory involved. */
     render(): {
         html: string;
         text: string;
@@ -425,7 +503,7 @@ declare class Dispatcher$2 implements NotificationDispatcher {
  * re-decides queued-or-now on whatever job it's handed — actually enqueues it instead of running it inline; the
  * notification's own queueability (checked by Dispatcher, above) only decides whether to wrap it at all. Like
  * Laravel's SendQueuedNotifications, it forwards failed(), retryUntil(), middleware() and displayName() to the
- * notification.
+ * notification. Unlike Laravel's, it is unique when the notification is (Laravel queues it past the unique lock).
  */
 declare class SendQueuedNotifications implements Job {
     readonly notifiables: Notifiable$1[];
@@ -987,7 +1065,7 @@ declare class RoutingServiceProvider extends ServiceProvider$1 {
 declare class ThrottleRequests implements Middleware {
     handle(request: HttpRequest, next: Next$1, maxAttempts?: string, decayMinutes?: string, prefix?: string): Promise<Response>;
     /** The signed-in user's identifier, else the client IP, hashed (Laravel's resolveRequestSignature()). */
-    protected resolveRequestSignature(request: HttpRequest): string;
+    protected resolveRequestSignature(request: HttpRequest): Promise<string>;
 }
 
 /**
@@ -1012,9 +1090,7 @@ declare function currentRequest(): HttpRequest | undefined;
 declare function optionalSession(): Session | undefined;
 declare function optionalCookieJar(): CookieJar$1 | undefined;
 
-type ErrorsInput = Record<string, string | string[]> | {
-    toObject(): Record<string, string[]>;
-};
+type ErrorsInput = Record<string, string | string[]> | MessageBag;
 /**
  * Laravel's RedirectResponse. with()/withErrors()/withInput() flash to the request's Session immediately, like
  * Laravel; without a bound Session (an API-only app) they are skipped silently.
@@ -1176,10 +1252,17 @@ declare class IncomingRequest implements HttpRequest {
     /** One route parameter (after model binding), or all of them. */
     route<T = unknown>(key?: string): T;
     session(): Session;
-    user<T = unknown>(guard?: string): T | undefined;
+    /**
+     * The signed-in user, through the resolver Auth sets, else the current scope's guard (the default, or `guard`).
+     * The guard keeps the user it found, so it is looked up once per request. Undefined for a guest or without auth.
+     */
+    user<T = unknown>(guard?: string): Promise<T | undefined>;
     setUserResolver(resolver: (guard?: string) => unknown): void;
-    /** Validates all() through the ValidationFactory; throws its Validation error on failure. */
-    validate<T = Record<string, unknown>>(rules: Rules, messages?: Record<string, string>, attributes?: Record<string, string>): Promise<T>;
+    /**
+     * Validates all() through the ValidationFactory; throws its Validation error on failure. The 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>>;
 }
 
 /** Helpers for request input: PHP-style bracket keys, safe cloning (no prototype pollution) and blank checks. */
@@ -1236,9 +1319,9 @@ declare function request<T = unknown>(key: string, defaultValue?: T): T;
 /** response() → the ResponseFactory; response(content, status, headers) → a Response. */
 declare function response(): ResponseFactory$1;
 declare function response(content: BodyInit | null, status?: number, headers?: HeadersInit): Response;
-/** The Redirector with its route() typed by the generated route names. */
+/** The Redirector with its route() typed by the generated route names and their parameters. */
 type TypedRedirector = Omit<Redirector, 'route'> & {
-    route(name: RouteName, parameters?: unknown, status?: number): RedirectResponse;
+    route<N extends RouteName>(name: N, ...args: RouteArguments<N, [status?: number]>): RedirectResponse;
 };
 /** redirect() → the Redirector; redirect('/path', status) → a RedirectResponse. */
 declare function redirect(): TypedRedirector;
@@ -1248,8 +1331,11 @@ declare function back(fallback?: string, status?: number): RedirectResponse;
 /** url() → the UrlGenerator; url('/path', query, absolute) → a URL. */
 declare function url(): UrlGenerator;
 declare function url(path: string, query?: Record<string, unknown>, absolute?: boolean): string;
-/** The URL of a named route. */
-declare function route(name: RouteName, parameters?: unknown, absolute?: boolean): string;
+/**
+ * The URL of a named route: route('posts.show', post), route('posts.show', { post, page: 2 }). Once `oriel
+ * route:types` has run, the name and the route's parameters are checked.
+ */
+declare function route<N extends RouteName>(name: N, ...args: RouteArguments<N>): string;
 /** abort(404), abort(403, 'Nope', headers), or abort(response) to send a ready response. */
 declare function abort(status: number | Response, message?: string, headers?: Record<string, string>): never;
 declare function abortIf(condition: unknown, status: number | Response, message?: string, headers?: Record<string, string>): void;
@@ -1375,7 +1461,10 @@ declare class ExceptionsConfiguration implements ExceptionsConfigurator {
 /** Runs the withExceptions() callbacks against a handler (the provider does this when the handler is built). */
 declare function applyExceptionCallbacks(app: Application$2, handler: ErrorHandler): void;
 
-/** Laravel's wording for the status (its error pages say "Server Error" and "Page Expired"). */
+/**
+ * The text an error page shows for a status: Laravel's own wording where it has a view ("Server Error", "Page
+ * Expired"), else Symfony's `Response::$statusTexts`, which Laravel shows for the others.
+ */
 declare function statusText(status: number): string;
 declare function escapeHtml(value: string): string;
 /** Laravel's minimal error page: "404 | Not Found". */
@@ -1464,6 +1553,28 @@ declare function serve(app: Application$2, options?: ServeOptions): Promise<Runn
  */
 declare function servePublicFile(publicPath: string, request: Request): Promise<Response | undefined>;
 
+interface FileWatcher {
+    close(): void;
+}
+
+/** node:child_process's spawn(), replaceable in tests. */
+type SpawnServer = (command: string, args: string[], options: SpawnOptions) => ChildProcess;
+interface WatchedServerOptions {
+    /** The server's command line: the runtime, its flags, the CLI script, then `serve --host=… --port=…`. */
+    command: readonly string[];
+    cwd: string;
+    env: NodeJS.ProcessEnv;
+    /** Starts watching: calls back with the changed files (relative to the base path) once they settle. */
+    watch(onChange: (files: string[]) => void): FileWatcher;
+    info(message: string): void;
+    error(message: string): void;
+    /** How long a server may take to stop before it is killed, in ms. Default 15000 (serve gives requests 10 s). */
+    stopTimeout?: number;
+    /** The signals that stop it. Default SIGINT, SIGTERM and SIGHUP. */
+    signals?: readonly NodeJS.Signals[];
+    spawn?: SpawnServer;
+}
+
 interface RouteListRow {
     /** 'GET|HEAD' */
     readonly method: string;
@@ -1503,6 +1614,8 @@ interface HttpCommandOptions {
     serve?: (app: Application$2, options: ServeOptions) => Promise<RunningServer>;
     /** The terminal width for route:list. Default: process.stdout.columns, else 120. */
     terminalWidth?: () => number;
+    /** Replaces `serve --watch`'s restarting server (tests). Resolves the command's exit code. */
+    watch?: (options: WatchedServerOptions) => Promise<number>;
 }
 /** Registers `serve`, `route:list` and `install:api` as closure commands (PC1). */
 declare function registerHttpCommands(kernel: ConsoleKernel, app: Application$2, options?: HttpCommandOptions): void;
@@ -1531,16 +1644,18 @@ declare const Schedule: Facade<Schedule$1, object>;
 
 /**
  * Bootstraps the app for the `oriel` CLI: marks it as running in the console, boots every provider (Console's
- * provider then loads routes/console.ts and app/Console/Commands), runs the command, and terminates the app, so
- * terminating callbacks close the DB pools and other handles that would keep the process alive. `boot()` runs
- * inside the try so a failure while booting still terminates the app. Relies on the process being started through
- * a loader that understands .ts (tsx on Node, native on Bun), like the rest of the skeleton.
+ * provider then loads routes/console.ts and app/Console/Commands), runs the command, and terminates the app, so its
+ * terminating callbacks run after the command as they do after a request (closing the DB pools and other handles is
+ * app.shutdown()'s job, which runConsoleAndExit() calls). `boot()` runs inside the try so a failure while booting
+ * still terminates the app. Relies on the process being started through a loader that understands .ts (tsx on Node,
+ * native on Bun), like the rest of the skeleton.
  */
 declare function runConsole(app: Application$2, argv?: string[]): Promise<number>;
 /**
- * What the skeleton's `oriel` entry calls: runConsole(), then exit with the command's exit code. The log files are
- * flushed first, also when the command throws: pino writes asynchronously and process.exit() doesn't wait, so a line
- * logged just before would be lost, and pino's exit hook would throw (on Bun that made the exit code 1).
+ * What the skeleton's `oriel` entry calls: runConsole(), then exit with the command's exit code. The app is shut down
+ * first, also when the command throws: its shutdown callbacks close the database pools and Redis clients and write out
+ * the log files (pino writes asynchronously and process.exit() doesn't wait, so a line logged just before would be
+ * lost, and pino's exit hook would throw: on Bun that made the exit code 1).
  */
 declare function runConsoleAndExit(app: Application$2, argv?: string[], exit?: (code: number) => void): Promise<void>;
 
@@ -1579,6 +1694,15 @@ declare class ScheduledEventImpl implements ScheduledEvent {
     private readonly filters;
     private readonly rejects;
     private betweenWindow;
+    private unlessWindow;
+    private repeatEverySeconds;
+    private readonly beforeCallbacks;
+    /** Each is told whether the event succeeded (onSuccess() and onFailure() pick one side). */
+    private readonly afterCallbacks;
+    /** When run() last started (Laravel's lastChecked), for the every-N-seconds repetitions. */
+    private lastChecked;
+    /** The minute slot this server won with onOneServer(): its repetitions in that minute keep it. */
+    private wonServerSlot;
     private overlapExpiryMinutes;
     private oneServer;
     private background;
@@ -1602,19 +1726,57 @@ declare class ScheduledEventImpl implements ScheduledEvent {
     everyFifteenMinutes(): this;
     everyThirtyMinutes(): this;
     hourly(): this;
-    hourlyAt(minute: number): this;
+    hourlyAt(minute: number | readonly number[]): this;
     daily(): this;
     dailyAt(time: string): this;
     twiceDaily(first?: number, second?: number): this;
     weekly(): this;
-    weeklyOn(day: number, time?: string): this;
+    weeklyOn(day: number | readonly number[], time?: string): this;
     monthly(): this;
     monthlyOn(day?: number, time?: string): this;
     yearly(): this;
     weekdays(): this;
     weekends(): this;
+    everySecond(): this;
+    everyTwoSeconds(): this;
+    everyFiveSeconds(): this;
+    everyTenSeconds(): this;
+    everyFifteenSeconds(): this;
+    everyTwentySeconds(): this;
+    everyThirtySeconds(): this;
+    everyTwoMinutes(): this;
+    everyThreeMinutes(): this;
+    everyFourMinutes(): this;
+    everyTenMinutes(): this;
+    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;
+    at(time: string): this;
+    twiceDailyAt(first?: number, second?: number, minute?: number): this;
+    mondays(): this;
+    tuesdays(): this;
+    wednesdays(): this;
+    thursdays(): this;
+    fridays(): this;
+    saturdays(): this;
+    sundays(): this;
+    twiceMonthly(first?: number, second?: number, time?: string): this;
+    /** Cron's `L`: the last day of whichever month it is, so a long-running schedule:work stays right. */
+    lastDayOfMonth(time?: string): this;
+    quarterly(): this;
+    quarterlyOn(day?: number, time?: string): this;
+    yearlyOn(month?: number, day?: number, time?: string): this;
+    days(days: number | readonly number[], ...more: number[]): this;
     timezone(timezone: string): this;
     between(start: string, end: string): this;
+    unlessBetween(start: string, end: string): this;
+    before(callback: ScheduleHook): this;
+    after(callback: ScheduleHook): this;
+    then(callback: ScheduleHook): this;
+    onSuccess(callback: ScheduleHook): this;
+    onFailure(callback: ScheduleHook): this;
     when(callback: Filter): this;
     skip(callback: Filter): this;
     withoutOverlapping(expiresAtMinutes?: number): this;
@@ -1629,18 +1791,36 @@ declare class ScheduledEventImpl implements ScheduledEvent {
     /** The same as getSummaryForDisplay(). */
     getSummary(): string;
     isBackground(): boolean;
+    /** The seconds between runs within a minute (everySecond() … everyThirtySeconds()), or undefined. */
+    getRepeatSeconds(): number | undefined;
+    /** Laravel's shouldRepeatNow(): an every-N-seconds event whose last run started N seconds ago or more. */
+    shouldRepeatNow(now: number): boolean;
+    /** Laravel's spliceIntoPosition(): replaces one cron field (0 = minute … 4 = day of the week). */
+    private splice;
+    private hourBased;
+    private atTime;
+    private repeatEvery;
     /**
      * Minute precision: `now` is truncated to the start of its minute, since cron-parser's includesDate() also
      * compares seconds. Without timezone(), expressions are read in app.timezone (UTC by default), as in Laravel.
      */
     isDue(now: Date): boolean;
     private zone;
+    /** Whether `now`, in the event's time zone, falls in the window (inclusive; one that crosses midnight too). */
     private isWithinWindow;
     /**
      * `startedAt` is the moment the scheduler found this event due. onOneServer() keys its lock on that minute, so
-     * servers that start the event a little late still compete for the same slot.
+     * servers that start the event a little late still compete for the same slot, and the server that wins keeps the
+     * slot for the event's every-N-seconds repetitions in that minute. `checkedAt` is when this run starts (a
+     * repetition's own moment), from which the next repetition counts.
      */
-    run(startedAt?: Date): Promise<void>;
+    run(startedAt?: Date, checkedAt?: Date): Promise<void>;
+    /**
+     * Runs the event and says whether it failed. A command fails when it exits non-zero, and a closure when it throws or
+     * returns false, as Laravel's CallbackEvent does. A job whose handler returns false failing is Oriel's own choice:
+     * Laravel's Schedule::job() wraps the dispatch in a closure that returns nothing.
+     */
+    private execute;
     /**
      * Follows Laravel: a command event's mutex is `sha1(expression + full command
      * string incl. parameters)` (Laravel's `Event::mutexName()`) — no `name()` required. A closure event (`call()`/
@@ -1818,6 +1998,11 @@ declare abstract class GeneratorCommand extends Command {
     protected suffix(): string;
     /** Extra {{ placeholder }} values beyond {{ class }}. */
     protected extraPlaceholders(_rawName: string): Record<string, string>;
+    /**
+     * Runs once the target is known to be free (or --force is set) and before the file is rendered: where a generator
+     * makes the files its own file imports (make:controller --model --requests), as Laravel does inside buildClass().
+     */
+    protected prepare(_rawName: string): Promise<void>;
     protected qualifyClass(rawName: string): {
         directories: string[];
         className: string;
@@ -1831,24 +2016,42 @@ declare abstract class GeneratorCommand extends Command {
     protected kind(): string;
     /** The import specifier from the generated file to `target` (an absolute path without extension): './X', '../Y/X'. */
     protected importPath(rawName: string, target: string): string;
+    /** A --model value as studly segments: 'Admin/blog_post' -> ['Admin', 'BlogPost']; undefined when there is none. */
+    protected modelSegments(value: unknown): string[] | undefined;
+    /** The model's file under app/Models, without the extension (Laravel's qualifyModel() into App\Models). */
+    protected modelPath(segments: string[]): string;
     handle(): Promise<number>;
 }
 
 declare class MakeControllerCommand extends GeneratorCommand {
-    readonly signature = "make:controller {name} {--resource} {--api} {--force}";
+    readonly signature: string;
     description: string;
     protected type(): string;
     protected suffix(): string;
+    /** Laravel's getStub(): --model, else --invokable, else --resource; --api picks the variant without create/edit. */
     protected stub(): string;
+    handle(): Promise<number>;
+    /**
+     * With --model: the model is generated when app/Models has no file for it (Laravel asks, and --no-interaction
+     * takes its default, yes), then with --requests the Store and Update form requests, as Laravel's buildClass().
+     */
+    protected prepare(): Promise<void>;
     protected extraPlaceholders(rawName: string): Record<string, string>;
 }
 
 declare class MakeModelCommand extends GeneratorCommand {
-    readonly signature = "make:model {name} {--m|migration} {--f|factory} {--s|seed} {--c|controller} {--resource} {--api} {--force}";
+    readonly signature: string;
     description: string;
     protected type(): string;
     protected stub(): string;
+    /** The factory make:factory writes for this model (database/factories/<Model>Factory.ts), for the model's type. */
+    protected extraPlaceholders(rawName: string): Record<string, string>;
+    /** Laravel's ModelMakeCommand::handle(): --all turns on every option but --api and --requests' own. */
     handle(): Promise<number>;
+    /** The option, or --all, which sets factory, seed, migration, controller, policy and resource (and requests). */
+    private wants;
+    /** Laravel's class_basename() of the name, studly: Admin/blog_post → BlogPost. */
+    private baseName;
 }
 
 declare class MakeCastCommand extends GeneratorCommand {
@@ -1901,12 +2104,22 @@ declare class MakeListenerCommand extends GeneratorCommand {
     protected extraPlaceholders(rawName: string): Record<string, string>;
 }
 
+/**
+ * Laravel's make:mail with its view: the mailable renders `mail.<name>` (Laravel's getView() default), written to
+ * resources/views as TSX. Laravel writes the view only with --view or --markdown; here it is always written, since a
+ * mailable without its view fails on the first send. Oriel has no markdown mail, so there is no --markdown.
+ */
 declare class MakeMailCommand extends GeneratorCommand {
-    readonly signature = "make:mail {name} {--force}";
+    readonly signature: string;
     description: string;
     protected type(): string;
     protected stub(): string;
     protected extraPlaceholders(rawName: string): Record<string, string>;
+    handle(): Promise<number>;
+    /** --view, else `mail.` and the name's parts in kebab case: Orders/InvoicePaid → mail.orders.invoice-paid. */
+    private viewName;
+    /** Laravel's writeView(): an existing view is reported and left alone, even with --force. */
+    private writeView;
 }
 
 declare class MakeMiddlewareCommand extends GeneratorCommand {
@@ -1932,11 +2145,16 @@ declare class MakeObserverCommand extends GeneratorCommand {
 }
 
 declare class MakePolicyCommand extends GeneratorCommand {
-    readonly signature = "make:policy {name} {--force}";
+    readonly signature = "make:policy {name} {--m|model= : The model that the policy applies to} {--force : Create the class even if the policy already exists}";
     description: string;
     protected type(): string;
     protected suffix(): string;
     protected stub(): string;
+    /**
+     * Laravel's replaceModel(): the model from app/Models and the app's User model (app/Models/User, the skeleton's
+     * auth model); the model's parameter is named `model` when the model is the User, so the two don't clash.
+     */
+    protected extraPlaceholders(rawName: string): Record<string, string>;
 }
 
 declare class MakeProviderCommand extends GeneratorCommand {
@@ -2018,6 +2236,29 @@ declare class ScheduleClearCacheCommand extends Command {
     handle(): Promise<number>;
 }
 
+/**
+ * Laravel's schedule:interrupt: tells a running schedule:run (or schedule:work) to stop repeating its every-N-seconds
+ * events for the rest of the minute, for a deploy. The signal lives in the cache until the minute ends.
+ */
+declare class ScheduleInterruptCommand extends Command {
+    private readonly clock;
+    readonly signature = "schedule:interrupt";
+    description: string;
+    /** `now` is overridable so tests can say which minute it is. */
+    constructor(clock?: {
+        now?: () => number;
+    });
+    handle(): Promise<number>;
+}
+
+/** The cache key schedule:interrupt sets until the minute ends (Laravel's `illuminate:schedule:interrupt`). */
+declare const SCHEDULE_INTERRUPT_KEY = "oriel:schedule:interrupt";
+/** The clock the repetitions read and wait on; the commands take their own so tests can move time on. */
+interface ScheduleClock {
+    now: () => number;
+    sleep: (ms: number) => Promise<void>;
+}
+
 declare class ScheduleListCommand extends Command {
     readonly signature = "schedule:list";
     description: string;
@@ -2025,8 +2266,11 @@ declare class ScheduleListCommand extends Command {
 }
 
 declare class ScheduleRunCommand extends Command {
+    private readonly clock;
     readonly signature = "schedule:run";
     description: string;
+    /** `now` and `sleep` are overridable so tests don't wait out a real minute. */
+    constructor(clock?: Partial<ScheduleClock>);
     handle(): Promise<number>;
 }
 
@@ -2257,6 +2501,8 @@ interface ColumnAttributes {
     after?: string;
     first?: boolean;
     onUpdate?: Expression;
+    /** Set by change(): the column exists and is redefined, not added. */
+    change?: boolean;
 }
 /** A column in a Blueprint, with Laravel's fluent modifiers: t.string('email').nullable().unique(). */
 declare class ColumnDefinition {
@@ -2282,6 +2528,12 @@ declare class ColumnDefinition {
     first(): this;
     /** default CURRENT_TIMESTAMP. */
     useCurrent(): this;
+    /**
+     * Redefines an existing column (Laravel's change()): t.string('title', 500).nullable().change(). As in Laravel 11+,
+     * the column becomes exactly this definition: a modifier it had and that isn't given again (nullable, default,
+     * comment, …) is dropped. On SQLite the table is rebuilt.
+     */
+    change(): this;
     /** MySQL only: on update CURRENT_TIMESTAMP. */
     useCurrentOnUpdate(): this;
 }
@@ -2342,8 +2594,12 @@ type BlueprintCommand = {
     from: string;
     to: string;
 } | {
-    name: 'dropPrimary' | 'dropUnique' | 'dropIndex' | 'dropForeign';
+    name: 'dropPrimary' | 'dropUnique' | 'dropIndex';
     index: string;
+} | {
+    name: 'dropForeign';
+    index: string;
+    columns?: string[];
 } | {
     name: 'rename';
     to: string;
@@ -2416,6 +2672,7 @@ declare class Blueprint {
     /** By name, or by columns (the conventional {table}_{columns}_unique name). */
     dropUnique(index: string | string[]): void;
     dropIndex(index: string | string[]): void;
+    /** By name, or by columns (the conventional name; SQLite needs the columns, it doesn't keep foreign key names). */
     dropForeign(index: string | string[]): void;
     /** Drops the foreign key on the column, then the column. */
     dropConstrainedForeignId(column: string): void;
@@ -2426,6 +2683,10 @@ declare class Blueprint {
     rename(to: string): void;
     drop(): void;
     dropIfExists(): void;
+    /** The columns this blueprint adds (not the ones change() redefines). */
+    addedColumns(): ColumnDefinition[];
+    /** The existing columns change() redefines (on a table being created, every column is added instead). */
+    changedColumns(): ColumnDefinition[];
     /** Laravel's default index name: {table}_{columns}_{type}, lowercased, with - and . replaced by _. */
     createIndexName(type: IndexType | 'foreign', columns: string[]): string;
     /** The index commands implied by column modifiers (t.string('email').unique()), in column order. */
@@ -2446,6 +2707,42 @@ interface ColumnInfo {
     default: string | null;
     auto_increment: boolean;
 }
+/** One index of an existing table, as reported by Schema.getIndexes() (Laravel's shape). */
+interface IndexInfo {
+    /** Lower-cased. The primary key is 'primary' on MySQL and on a SQLite rowid table, `{table}_pkey` on Postgres. */
+    name: string;
+    columns: string[];
+    /** The index method ('btree', 'hash', …) on Postgres and MySQL; null on SQLite. */
+    type: string | null;
+    unique: boolean;
+    primary: boolean;
+}
+/** One foreign key of an existing table, as reported by Schema.getForeignKeys() (Laravel's shape). */
+interface ForeignKeyInfo {
+    /** The constraint name; null on SQLite, which doesn't keep it. */
+    name: string | null;
+    columns: string[];
+    foreign_schema: string;
+    foreign_table: string;
+    /** Empty when a SQLite key names only the table (it then points at that table's primary key). */
+    foreign_columns: string[];
+    /** 'cascade', 'restrict', 'set null', 'set default' or 'no action'. */
+    on_update: string;
+    on_delete: string;
+}
+/**
+ * A step a blueprint can't express as fixed SQL: on SQLite, rebuilding the table from its live definition plus these
+ * key commands and changed columns. SchemaBuilder.build() runs it (Schema/SqliteTableRebuild.ts).
+ */
+interface TableRebuild {
+    readonly kind: 'rebuild';
+    readonly table: string;
+    readonly commands: BlueprintCommand[];
+    readonly changes: ColumnDefinition[];
+}
+/** One step of a compiled blueprint: a statement, or a table rebuild. */
+type SchemaStep = Sql$1 | TableRebuild;
+declare const isTableRebuild: (step: SchemaStep) => step is TableRebuild;
 /**
  * Turns a Blueprint into DDL for one driver (Laravel's Schema\Grammars). Identifiers go through sql.id();
  * default values and comments are quoted literals (sql.lit); only DB.raw() defaults are written as-is.
@@ -2455,11 +2752,18 @@ declare abstract class SchemaGrammar {
     abstract readonly driver: DriverName;
     constructor(config?: Partial<ConnectionConfig$1>);
     static for(driver: DriverName, config?: Partial<ConnectionConfig$1>): SchemaGrammar;
-    /** Every statement for the blueprint: create/add first, then commands in order, then indexes from column modifiers. */
+    /**
+     * Every statement for the blueprint: create/add first, then commands in order, then indexes from column modifiers.
+     * A blueprint that can only run against the live table (a SQLite rebuild) throws: run it with Schema.table().
+     */
     compile(blueprint: Blueprint): Sql$1[];
+    /** compile() with table rebuilds as steps of their own; consecutive rebuilds of one run are merged into one. */
+    compileSteps(blueprint: Blueprint): SchemaStep[];
     protected compileCreate(blueprint: Blueprint, _commands: BlueprintCommand[], _handled: Set<BlueprintCommand>): Sql$1;
     protected compileAdd(blueprint: Blueprint, _commands: BlueprintCommand[], _handled: Set<BlueprintCommand>): Sql$1[];
-    protected compileCommand(blueprint: Blueprint, command: BlueprintCommand): Sql$1[];
+    /** Redefines an existing column (change()). */
+    protected abstract compileChange(blueprint: Blueprint, column: ColumnDefinition): SchemaStep[];
+    protected compileCommand(blueprint: Blueprint, command: BlueprintCommand): SchemaStep[];
     compileRename(from: string, to: string): Sql$1;
     compileDrop(table: string): Sql$1;
     compileDropIfExists(table: string): Sql$1;
@@ -2486,16 +2790,28 @@ declare abstract class SchemaGrammar {
     abstract compileTables(): Sql$1;
     abstract compileColumns(table: string): Sql$1;
     abstract normalizeColumns(rows: Array<Record<string, unknown>>, tableSql?: string): ColumnInfo[];
+    abstract compileIndexes(table: string): Sql$1;
+    abstract normalizeIndexes(rows: Array<Record<string, unknown>>): IndexInfo[];
+    abstract compileForeignKeys(table: string): Sql$1;
+    abstract normalizeForeignKeys(rows: Array<Record<string, unknown>>): ForeignKeyInfo[];
     abstract compileEnableForeignKeyConstraints(): Sql$1;
     abstract compileDisableForeignKeyConstraints(): Sql$1;
 }
 declare class SqliteSchemaGrammar extends SchemaGrammar {
     readonly driver: "sqlite";
-    /** SQLite can't add keys to an existing table, so primary and foreign keys go inside create table. */
+    /** A new table's primary and foreign keys go inside create table (adding them later rebuilds the table). */
     protected compileCreate(blueprint: Blueprint, commands: BlueprintCommand[], handled: Set<BlueprintCommand>): Sql$1;
     /** New columns may carry an inline `references` clause (the only foreign key SQLite can add later). */
     protected compileAdd(blueprint: Blueprint, commands: BlueprintCommand[], handled: Set<BlueprintCommand>): Sql$1[];
-    protected compileCommand(blueprint: Blueprint, command: BlueprintCommand): Sql$1[];
+    /**
+     * SQLite can't add or drop a primary or foreign key on an existing table: those commands rebuild the table (Laravel
+     * 11+'s compileAlter), as a step SchemaBuilder.build() runs against the live table.
+     */
+    protected compileCommand(blueprint: Blueprint, command: BlueprintCommand): SchemaStep[];
+    /** SQLite can't alter a column: changing one rebuilds the table with the new definition. */
+    protected compileChange(blueprint: Blueprint, column: ColumnDefinition): SchemaStep[];
+    /** `foreign key (…) references … on delete …`, a table constraint of a rebuilt table. */
+    compileForeignKeyConstraint(foreign: ForeignKeyDefinition): Sql$1;
     protected compileUnique(blueprint: Blueprint, index: string, columns: string[]): Sql$1;
     protected compileDropUnique(_blueprint: Blueprint, index: string): Sql$1;
     protected type(column: ColumnDefinition): Sql$1;
@@ -2503,17 +2819,34 @@ declare class SqliteSchemaGrammar extends SchemaGrammar {
     compileTables(): Sql$1;
     compileColumns(table: string): Sql$1;
     normalizeColumns(rows: Array<Record<string, unknown>>): ColumnInfo[];
+    /** Laravel's query: the primary key from pragma_table_xinfo, then every index of pragma_index_list with its columns. */
+    compileIndexes(table: string): Sql$1;
+    /** A table whose primary key has its own index (not a rowid alias) lists it twice: the index entry is kept. */
+    normalizeIndexes(rows: Array<Record<string, unknown>>): IndexInfo[];
+    compileForeignKeys(table: string): Sql$1;
+    normalizeForeignKeys(rows: Array<Record<string, unknown>>): ForeignKeyInfo[];
     compileEnableForeignKeyConstraints(): Sql$1;
     compileDisableForeignKeyConstraints(): Sql$1;
 }
 declare class PostgresSchemaGrammar extends SchemaGrammar {
     readonly driver: "pgsql";
+    /** A changed column's comment is set again, or cleared (`is NULL`) when the new definition has none (Laravel 11+). */
     protected compileComments(blueprint: Blueprint): Sql$1[];
+    /**
+     * Laravel's compileChange(): `alter column` for the type, the nullability and the default, in one statement. A serial
+     * type becomes its integer type (the sequence stays), and an auto-increment column keeps its default. No `using`
+     * clause: a change Postgres can't cast implicitly fails, as in Laravel.
+     */
+    protected compileChange(blueprint: Blueprint, column: ColumnDefinition): SchemaStep[];
     protected type(column: ColumnDefinition): Sql$1;
     protected modifiers(column: ColumnDefinition): Sql$1[];
     compileTables(): Sql$1;
     compileColumns(table: string): Sql$1;
     normalizeColumns(rows: Array<Record<string, unknown>>): ColumnInfo[];
+    compileIndexes(table: string): Sql$1;
+    normalizeIndexes(rows: Array<Record<string, unknown>>): IndexInfo[];
+    compileForeignKeys(table: string): Sql$1;
+    normalizeForeignKeys(rows: Array<Record<string, unknown>>): ForeignKeyInfo[];
     compileEnableForeignKeyConstraints(): Sql$1;
     compileDisableForeignKeyConstraints(): Sql$1;
 }
@@ -2521,6 +2854,8 @@ declare class MySqlSchemaGrammar extends SchemaGrammar {
     readonly driver: "mysql";
     protected compileCreate(blueprint: Blueprint, commands: BlueprintCommand[], handled: Set<BlueprintCommand>): Sql$1;
     protected compileAdd(blueprint: Blueprint): Sql$1[];
+    /** Laravel's compileChange(): `modify` with the column's whole new definition. */
+    protected compileChange(blueprint: Blueprint, column: ColumnDefinition): SchemaStep[];
     protected compileUnique(blueprint: Blueprint, index: string, columns: string[]): Sql$1;
     protected compileIndex(blueprint: Blueprint, index: string, columns: string[]): Sql$1;
     protected compileDropPrimary(blueprint: Blueprint): Sql$1;
@@ -2532,6 +2867,10 @@ declare class MySqlSchemaGrammar extends SchemaGrammar {
     compileTables(): Sql$1;
     compileColumns(table: string): Sql$1;
     normalizeColumns(rows: Array<Record<string, unknown>>): ColumnInfo[];
+    compileIndexes(table: string): Sql$1;
+    normalizeIndexes(rows: Array<Record<string, unknown>>): IndexInfo[];
+    compileForeignKeys(table: string): Sql$1;
+    normalizeForeignKeys(rows: Array<Record<string, unknown>>): ForeignKeyInfo[];
     compileEnableForeignKeyConstraints(): Sql$1;
     compileDisableForeignKeyConstraints(): Sql$1;
 }
@@ -2554,7 +2893,10 @@ declare class SchemaBuilder {
     drop(table: string): Promise<void>;
     dropIfExists(table: string): Promise<void>;
     rename(from: string, to: string): Promise<void>;
-    /** Runs a blueprint's statements. Also useful to inspect the DDL: grammar.compile(blueprint). */
+    /**
+     * Runs a blueprint's statements in order (inspect them with grammar.compile(blueprint)). On SQLite, a change to the
+     * keys of an existing table rebuilds it from its live definition at its place in that order.
+     */
     build(blueprint: Blueprint): Promise<void>;
     /** The table names of the connection's database (or current schema on Postgres). */
     getTables(): Promise<string[]>;
@@ -2564,6 +2906,16 @@ declare class SchemaBuilder {
     /** Case-insensitive, like Laravel. */
     hasColumn(table: string, column: string): Promise<boolean>;
     hasColumns(table: string, columns: string[]): Promise<boolean>;
+    /** The table's indexes, its primary key included (Laravel's getIndexes()). */
+    getIndexes(table: string): Promise<IndexInfo[]>;
+    getIndexListing(table: string): Promise<string[]>;
+    /**
+     * Whether the table has an index with this name, or on exactly these columns (in order). `type` narrows it:
+     * 'primary', 'unique', or an index method such as 'btree'.
+     */
+    hasIndex(table: string, index: string | string[], type?: string): Promise<boolean>;
+    /** The table's foreign keys (Laravel's getForeignKeys()). */
+    getForeignKeys(table: string): Promise<ForeignKeyInfo[]>;
     enableForeignKeyConstraints(): Promise<void>;
     disableForeignKeyConstraints(): Promise<void>;
     /**
@@ -2833,6 +3185,13 @@ declare class Grammar {
     compileOrders(query: Builder$1<unknown>): Sql | undefined;
     compileWheres(wheres: readonly Where[], keyword?: 'where' | 'on'): Sql | undefined;
     compileWhere(where: Where): Sql;
+    /**
+     * whereDate(), whereTime(), whereDay(), whereMonth() and whereYear() per driver, as Laravel 12's grammars: MySQL's
+     * date()/time()/day()/month()/year(), Postgres' ::date, ::time and extract(), SQLite's strftime() compared as text.
+     */
+    compileWhereDate(where: Extract<Where, {
+        type: 'date';
+    }>): Sql;
     /**
      * whereLike() per driver, as Laravel 12's grammars: Postgres compares the column as text with ilike (like when
      * case-sensitive); MySQL uses like (like binary); SQLite uses like, or glob with the pattern translated.
@@ -2915,7 +3274,20 @@ type Where = {
     sql: string;
     bindings: readonly unknown[];
     boolean: WhereBoolean;
+} | {
+    type: 'date';
+    part: DatePart;
+    column: ColumnRef;
+    operator: string;
+    value: unknown;
+    boolean: WhereBoolean;
 };
+/** The part of a date or time column a date where clause compares (whereDate() → 'date', whereYear() → 'year', …). */
+type DatePart = 'date' | 'time' | 'day' | 'month' | 'year';
+/** What a date where clause compares with: a Date (read in UTC), a string, a number, or DB.raw(). */
+type DateWhereValue = Date | string | number | Expression;
+/** whereDate('published_at', '2026-01-05') or whereDate('published_at', '>=', new Date()). */
+type DateWhereArgs = [value: DateWhereValue] | [operator: string, value: DateWhereValue];
 type Having = {
     column: ColumnRef;
     operator: string;
@@ -2931,9 +3303,11 @@ type Order = {
 } | {
     raw: Expression;
 };
+/** A column, an expression, or `(subquery) as alias` (`exists (subquery) as alias` with exists). */
 type SelectColumn = ColumnRef | {
     query: Builder$1<unknown>;
     as: string;
+    exists?: boolean;
 };
 type NestedCallback<Q> = (query: Q) => unknown;
 /** The value when()'s callback receives: the condition's type without its falsy members. */
@@ -2988,6 +3362,21 @@ declare class Builder$1<T = Row> implements QueryBuilder<T> {
     whereBetween(column: ColumnRef, values: readonly [unknown, unknown]): this;
     orWhereBetween(column: ColumnRef, values: readonly [unknown, unknown]): this;
     whereNotBetween(column: ColumnRef, values: readonly [unknown, unknown]): this;
+    /** Compares the date part of a column: whereDate('published_at', '2026-01-05'), whereDate('published_at', '<', new Date()). */
+    whereDate(column: ColumnRef, ...args: DateWhereArgs): this;
+    orWhereDate(column: ColumnRef, ...args: DateWhereArgs): this;
+    /** Compares the time of day: whereTime('published_at', '>=', '09:00:00'). */
+    whereTime(column: ColumnRef, ...args: DateWhereArgs): this;
+    orWhereTime(column: ColumnRef, ...args: DateWhereArgs): this;
+    /** Compares the day of the month: whereDay('published_at', 5). */
+    whereDay(column: ColumnRef, ...args: DateWhereArgs): this;
+    orWhereDay(column: ColumnRef, ...args: DateWhereArgs): this;
+    /** Compares the month: whereMonth('published_at', 12). */
+    whereMonth(column: ColumnRef, ...args: DateWhereArgs): this;
+    orWhereMonth(column: ColumnRef, ...args: DateWhereArgs): this;
+    /** Compares the year: whereYear('published_at', '>=', 2026). */
+    whereYear(column: ColumnRef, ...args: DateWhereArgs): this;
+    orWhereYear(column: ColumnRef, ...args: DateWhereArgs): this;
     /**
      * Laravel's whereLike(): the value is the pattern, `%` and `_` included (`whereLike('title', `%${term}%`)`).
      * Case-insensitive unless caseSensitive: ilike on Postgres, like on MySQL and SQLite (their like already ignores
@@ -3048,6 +3437,8 @@ declare class Builder$1<T = Row> implements QueryBuilder<T> {
     unless<V>(value: V, callback: (query: this, value: V) => unknown, otherwise?: (query: this, value: Truthy<V>) => unknown): this;
     tap(callback: (query: this) => unknown): this;
     get(): Promise<Collection<T>>;
+    /** The collection get() and chunk() hand out (Eloquent's builder makes the model's collection). */
+    protected newCollection(items: T[]): Collection<T>;
     /** The raw rows, without a Collection around them. */
     runSelect(): Promise<T[]>;
     first(): Promise<T | undefined>;
@@ -3128,6 +3519,8 @@ declare class Builder$1<T = Row> implements QueryBuilder<T> {
     private subQuery;
     private addNested;
     private addWhere;
+    /** Laravel's addDateBasedWhere(): one value means '='; the operator is checked against the whitelist. */
+    private addDateBasedWhere;
     private pushNull;
 }
 type JoinType = 'inner' | 'left' | 'right' | 'cross';
@@ -3235,6 +3628,106 @@ declare const SchemaBuilderToken: Token<SchemaBuilder>;
 /** The Schema facade: Schema.create('posts', (t) => { … }), Schema.table(…), Schema.dropIfExists(…). */
 declare const Schema: Facade<SchemaBuilder, object>;
 
+/**
+ * A custom cast (Laravel's CastsAttributes): get() turns the stored value into what the model exposes, set() turns
+ * an assigned value back into what is stored.
+ */
+interface CastsAttributes<TGet = unknown, TSet = TGet> {
+    get(model: object, key: string, value: unknown, attributes: Row): TGet;
+    set(model: object, key: string, value: TSet, attributes: Row): unknown;
+}
+/** A TypeScript enum object (string or numeric) used as a cast: casts = { status: PostStatus }. */
+type EnumLike$1 = Record<string, string | number>;
+type BuiltInCast = 'int' | 'integer' | 'float' | 'double' | 'real' | 'string' | 'bool' | 'boolean' | 'array' | 'json' | 'object' | 'collection' | 'date' | 'datetime' | 'immutable_date' | 'immutable_datetime' | 'timestamp' | 'hashed' | `decimal:${number}`;
+type CastDefinition = BuiltInCast | EnumLike$1 | CastsAttributes | (new () => CastsAttributes);
+/** The values of a TypeScript enum. Numeric enums also map values back to names; those reverse entries are skipped. */
+declare function enumValues(cast: EnumLike$1): Array<string | number>;
+declare const isJsonCast: (cast: CastDefinition | undefined) => boolean;
+declare const isDateCast: (cast: CastDefinition | undefined) => boolean;
+/** Laravel's castAttribute(): the stored value → the value the model exposes. null stays null (except custom casts). */
+declare function castGet(model: object, key: string, cast: CastDefinition, value: unknown, attributes: Row, className: string): unknown;
+/** The value assigned to a cast attribute → the value stored in the model's attributes (and later bound). */
+declare function castSet(model: object, key: string, cast: CastDefinition, value: unknown, attributes: Row, className: string): unknown;
+/**
+ * Laravel's originalIsEquivalent(): does the stored value still mean the same thing as the original?
+ * Keeps save() from writing columns whose value only changed representation (1 vs true, '5' vs 5, same instant).
+ */
+declare function isEquivalent(cast: CastDefinition | undefined, current: unknown, original: unknown, model: object, key: string, className: string): boolean;
+
+/**
+ * Laravel's Eloquent collection: what every query, relation and eager load of models returns. It is a support
+ * Collection (methods that keep the items keep this class; map() and the other type-changing methods return a plain
+ * Collection) with the model-aware methods: find() by key, load() and loadCount() for every model at once, fresh(),
+ * modelKeys(), toQuery(), and diff()/intersect()/unique()/only()/except()/merge() that compare models by key.
+ */
+declare class EloquentCollection<M extends Model = Model> extends Collection<M> {
+    /** The model with this key (or this model's key), else the default; with several keys, those models. */
+    find(key: readonly unknown[] | Collection<unknown>): this;
+    find(key: unknown): M | undefined;
+    find<D>(key: unknown, defaultValue: D): M | D;
+    /** find(), or ModelNotFoundError naming the missing keys. */
+    findOrFail(keys: readonly unknown[] | Collection<unknown>): this;
+    findOrFail(key: unknown): M;
+    /** The primary keys, in order. */
+    modelKeys(): unknown[];
+    /** The models keyed by their primary key (as text). */
+    getDictionary(items?: Iterable<M>): Record<string, M>;
+    /** The same models in a plain Collection. */
+    toBase(): Collection<M>;
+    /** Whether a model with this key (or this model) is in the collection; the other forms are Collection's. */
+    contains(key: keyof M & string, value: unknown): boolean;
+    contains(key: (keyof M & string) | ((item: M) => unknown), operator: Operator$1, value: unknown): boolean;
+    contains(callback: (item: M) => boolean): boolean;
+    contains(value: unknown): boolean;
+    /** Collection's containsStrict(): a model matches only itself (no key matching). */
+    containsStrict(key: keyof M & string, value: unknown): boolean;
+    containsStrict(callback: (item: M) => boolean): boolean;
+    containsStrict(value: unknown): boolean;
+    /** Collection's doesntContainStrict(): a model matches only itself (no key matching). */
+    doesntContainStrict(key: keyof M & string, value: unknown): boolean;
+    doesntContainStrict(callback: (item: M) => boolean): boolean;
+    doesntContainStrict(value: unknown): boolean;
+    /** Eager loads relations onto every model, one query per relation: await posts.load('author', 'comments.author'). */
+    load(...relations: EagerLoadSpec[]): Promise<this>;
+    /** Loads only the relations that aren't loaded yet; nested paths are followed into the loaded relations. */
+    loadMissing(...relations: string[]): Promise<this>;
+    /** Adds <relation>_count attributes to every model with one query: await posts.loadCount('comments'). */
+    loadCount(...relations: EagerLoadSpec[]): Promise<this>;
+    /**
+     * Laravel's loadAggregate(): withAggregate() for models already loaded, with one query for the whole collection.
+     * The values become clean attributes (with their casts: loadExists() gives booleans).
+     */
+    loadAggregate(relations: EagerLoadSpec | EagerLoadSpec[], column: string | Expression, fn?: string): Promise<this>;
+    /** Adds <relation>_sum_<column> to every model: await users.loadSum('orders', 'price'). */
+    loadSum(relations: EagerLoadSpec | EagerLoadSpec[], column: string | Expression): Promise<this>;
+    loadAvg(relations: EagerLoadSpec | EagerLoadSpec[], column: string | Expression): Promise<this>;
+    loadMin(relations: EagerLoadSpec | EagerLoadSpec[], column: string | Expression): Promise<this>;
+    loadMax(relations: EagerLoadSpec | EagerLoadSpec[], column: string | Expression): Promise<this>;
+    /** Adds a boolean <relation>_exists to every model. */
+    loadExists(...relations: EagerLoadSpec[]): Promise<this>;
+    /** The models as they are in the database now (without global scopes), with relations loaded; deleted ones drop out. */
+    fresh(...relations: EagerLoadSpec[]): Promise<this>;
+    /** The models whose keys aren't in the given models. */
+    diff(items: Iterable<M>): this;
+    /** The models whose keys are also in the given models. */
+    intersect(items: Iterable<M>): this;
+    /** One model per key (the last instance, at the first one's place); with a key or callback, Collection's unique(). */
+    unique(key?: (keyof M & string) | ((item: M) => unknown)): this;
+    /** The models with these keys, in the collection's order. */
+    only(...keys: unknown[]): this;
+    /** The models without these keys, in the collection's order. */
+    except(...keys: unknown[]): this;
+    /** Adds the given models, replacing the ones with the same key. */
+    merge(items: Iterable<M>): this;
+    makeHidden(...attributes: Array<string | string[]>): this;
+    makeVisible(...attributes: Array<string | string[]>): this;
+    setVisible(visible: string[]): this;
+    setHidden(hidden: string[]): this;
+    append(...attributes: Array<string | string[]>): this;
+    /** A query of exactly these models (where key in …), for mass updates: await posts.toQuery().update({ … }). */
+    toQuery(): Builder<M>;
+}
+
 /**
  * A relation is the related model's query builder, constrained to the parent: post.comments() is a
  * Builder<Comment> with `where comments.post_id = ?`, so every builder method (where, orderBy, paginate, a local
@@ -3336,6 +3829,8 @@ declare class Builder<M extends Model = Model> extends Builder$1<M> {
     protected scopes: Map<string, GlobalScope>;
     protected removedScopes: string[];
     protected eagerLoad: Map<string, RelationConstraint | undefined>;
+    /** Casts for the selected columns (withCasts()), merged into every model this query hydrates. */
+    protected selectCasts: Record<string, CastDefinition>;
     constructor(model: M);
     getModel(): M;
     /** The model class's static scope<Name> method for a builder method name, if any. */
@@ -3366,6 +3861,16 @@ declare class Builder<M extends Model = Model> extends Builder$1<M> {
     whereNull(columns: Column<M> | Expression | Array<Column<M> | Expression>): this;
     whereNotNull(columns: Column<M> | Expression | Array<Column<M> | Expression>): this;
     whereBetween(column: Column<M> | Expression, values: readonly [unknown, unknown]): this;
+    whereDate(column: Column<M> | Expression, ...args: DateWhereArgs): this;
+    orWhereDate(column: Column<M> | Expression, ...args: DateWhereArgs): this;
+    whereTime(column: Column<M> | Expression, ...args: DateWhereArgs): this;
+    orWhereTime(column: Column<M> | Expression, ...args: DateWhereArgs): this;
+    whereDay(column: Column<M> | Expression, ...args: DateWhereArgs): this;
+    orWhereDay(column: Column<M> | Expression, ...args: DateWhereArgs): this;
+    whereMonth(column: Column<M> | Expression, ...args: DateWhereArgs): this;
+    orWhereMonth(column: Column<M> | Expression, ...args: DateWhereArgs): this;
+    whereYear(column: Column<M> | Expression, ...args: DateWhereArgs): this;
+    orWhereYear(column: Column<M> | Expression, ...args: DateWhereArgs): this;
     whereLike(column: Column<M> | Expression, value: string, caseSensitive?: boolean, boolean?: WhereBoolean, not?: boolean): this;
     orWhereLike(column: Column<M> | Expression, value: string, caseSensitive?: boolean): this;
     whereNotLike(column: Column<M> | Expression, value: string, caseSensitive?: boolean, boolean?: WhereBoolean): this;
@@ -3378,6 +3883,12 @@ declare class Builder<M extends Model = Model> extends Builder$1<M> {
     /** where key = id (or key in ids). */
     whereKey(id: unknown): this;
     whereKeyNot(id: unknown): this;
+    /** The models, in the model's collection (an EloquentCollection). */
+    get(): Promise<EloquentCollection<M>>;
+    protected newCollection(models: M[]): EloquentCollection<M>;
+    /** chunk() with each chunk in the model's collection. */
+    chunk(count: number, callback: (models: EloquentCollection<M>, page: number) => unknown): Promise<boolean>;
+    chunkById(count: number, callback: (models: EloquentCollection<M>, page: number) => unknown, column?: string, alias?: string): Promise<boolean>;
     /** Runs the query, hydrates models, fires their retrieved events and eager loads the with() relations. */
     runSelect(): Promise<M[]>;
     /**
@@ -3400,6 +3911,25 @@ declare class Builder<M extends Model = Model> extends Builder$1<M> {
      * withCount('comments as approved_count'). Global scopes of the related model (soft deletes) apply.
      */
     withCount(...relations: EagerLoadSpec[]): this;
+    /** Adds `<relation>_sum_<column>`: withSum('orders', 'price'), withSum({ 'orders as paid': (q) => … }, 'price'). */
+    withSum(relations: EagerLoadSpec | EagerLoadSpec[], column: string | Expression): this;
+    /** Adds `<relation>_avg_<column>`. */
+    withAvg(relations: EagerLoadSpec | EagerLoadSpec[], column: string | Expression): this;
+    /** Adds `<relation>_min_<column>`. */
+    withMin(relations: EagerLoadSpec | EagerLoadSpec[], column: string | Expression): this;
+    /** Adds `<relation>_max_<column>`. */
+    withMax(relations: EagerLoadSpec | EagerLoadSpec[], column: string | Expression): this;
+    /** Adds a boolean `<relation>_exists`: withExists('comments'). */
+    withExists(...relations: EagerLoadSpec[]): this;
+    /**
+     * Laravel's withAggregate(): a correlated subquery per relation, `select <fn>(<related column>) … as <alias>`, the
+     * alias being `<relation>_<fn>_<column>` unless the relation is named `'orders as alias'`. The relation's
+     * constraint and the related model's global scopes apply; orderings are dropped. 'exists' selects
+     * `exists (…)`, cast to a boolean. Without a function the column's first value is selected.
+     */
+    withAggregate(relations: EagerLoadSpec | EagerLoadSpec[], column: string | Expression, fn?: string): this;
+    /** Casts for selected columns, as if the model declared them: withCasts({ orders_sum_price: 'float' }). */
+    withCasts(casts: Readonly<Record<string, CastDefinition>>): this;
     /**
      * Rows that have related rows: has('comments'), has('comments', '>=', 3), has('comments.author').
      * Uses `exists (…)` for the common "at least one"/"none" cases and a count subquery otherwise.
@@ -3426,9 +3956,9 @@ declare class Builder<M extends Model = Model> extends Builder$1<M> {
     protected isMalformedKey(id: unknown): boolean;
     /** A malformed unique id (HasUuids, HasUlids) finds nothing without a query, as route model binding does. */
     find(id: unknown): Promise<M | undefined>;
-    findMany(ids: readonly unknown[]): Promise<Collection<M>>;
+    findMany(ids: readonly unknown[]): Promise<EloquentCollection<M>>;
     /** find(), or ModelNotFoundError (a 404). With an array, every id must exist. */
-    findOrFail(ids: readonly unknown[]): Promise<Collection<M>>;
+    findOrFail(ids: readonly unknown[]): Promise<EloquentCollection<M>>;
     findOrFail(id: unknown): Promise<M>;
     findOr<R>(id: unknown, callback: () => R | Promise<R>): Promise<M | R>;
     firstOrFail(): Promise<M>;
@@ -3474,32 +4004,6 @@ declare class Builder<M extends Model = Model> extends Builder$1<M> {
     protected defaultPerPage(): number;
 }
 
-/**
- * A custom cast (Laravel's CastsAttributes): get() turns the stored value into what the model exposes, set() turns
- * an assigned value back into what is stored.
- */
-interface CastsAttributes<TGet = unknown, TSet = TGet> {
-    get(model: object, key: string, value: unknown, attributes: Row): TGet;
-    set(model: object, key: string, value: TSet, attributes: Row): unknown;
-}
-/** A TypeScript enum object (string or numeric) used as a cast: casts = { status: PostStatus }. */
-type EnumLike = Record<string, string | number>;
-type BuiltInCast = 'int' | 'integer' | 'float' | 'double' | 'real' | 'string' | 'bool' | 'boolean' | 'array' | 'json' | 'object' | 'collection' | 'date' | 'datetime' | 'immutable_date' | 'immutable_datetime' | 'timestamp' | `decimal:${number}`;
-type CastDefinition = BuiltInCast | EnumLike | CastsAttributes | (new () => CastsAttributes);
-/** The values of a TypeScript enum. Numeric enums also map values back to names; those reverse entries are skipped. */
-declare function enumValues(cast: EnumLike): Array<string | number>;
-declare const isJsonCast: (cast: CastDefinition | undefined) => boolean;
-declare const isDateCast: (cast: CastDefinition | undefined) => boolean;
-/** Laravel's castAttribute(): the stored value → the value the model exposes. null stays null (except custom casts). */
-declare function castGet(model: object, key: string, cast: CastDefinition, value: unknown, attributes: Row, className: string): unknown;
-/** The value assigned to a cast attribute → the value stored in the model's attributes (and later bound). */
-declare function castSet(model: object, key: string, cast: CastDefinition, value: unknown, attributes: Row, className: string): unknown;
-/**
- * Laravel's originalIsEquivalent(): does the stored value still mean the same thing as the original?
- * Keeps save() from writing columns whose value only changed representation (1 vs true, '5' vs 5, same instant).
- */
-declare function isEquivalent(cast: CastDefinition | undefined, current: unknown, original: unknown, model: object, key: string, className: string): boolean;
-
 declare const MANY: unique symbol;
 /** Type-level marker set by count(): make()/create() then return a Collection. */
 interface Many {
@@ -3516,6 +4020,17 @@ interface StateContext {
 }
 type State = Row | ((attributes: Row, context: StateContext) => Row);
 type AnyFactory = Factory<any>;
+/**
+ * What has() and for() need from a factory: its model, create(), createOne() and state(). A factory of any model,
+ * counted or not, has them; Factory<any> itself would refuse a counted one, whose make(), create() and raw() return
+ * lists.
+ */
+interface RelatedFactory {
+    readonly model: new () => Model;
+    create(attributes?: Row): Promise<unknown>;
+    createOne(attributes?: Row): Promise<Model>;
+    state(state: State): RelatedFactory;
+}
 /**
  * A model's factory() typed as its own factory class (Laravel's `@use HasFactory<UserFactory>`): declare it in the
  * model, `declare static factory: HasFactory<UserFactory>` (with `import type`), and User.factory().unverified()
@@ -3526,12 +4041,12 @@ type HasFactory<F> = {
     (count: number, state?: State): F & Many;
 } & (typeof Model)['factory'];
 interface HasRelationship {
-    factory: AnyFactory;
+    factory: RelatedFactory;
     relationship: string;
     pivot: Row;
 }
 interface ForRelationship {
-    parent: AnyFactory | Model;
+    parent: RelatedFactory | Model;
     relationship: string;
     resolved?: Model;
 }
@@ -3577,9 +4092,9 @@ declare abstract class Factory<M extends Model = Model> {
     /** deleted_at = now, for soft-deleting models. */
     trashed(): this;
     /** Creates related models for each created model: has(Post.factory().count(3)) (relationship default: 'posts'). */
-    has(factory: AnyFactory, relationship?: string, pivot?: Row): this;
+    has(factory: RelatedFactory, relationship?: string, pivot?: Row): this;
     /** Sets a belongsTo parent: for(User.factory()) or for(user) (relationship default: 'user'). Created once. */
-    for(parent: AnyFactory | Model, relationship?: string): this;
+    for(parent: RelatedFactory | Model, relationship?: string): this;
     afterMaking(callback: (model: M) => unknown): this;
     afterCreating(callback: (model: M) => unknown): this;
     /** The attributes only, without a model (a Row, or a Row[] after count()). */
@@ -3651,7 +4166,7 @@ interface SyncChanges {
  * Many-to-many through a pivot table: post.tags() → belongsToMany(Tag) over post_tag (post_id, tag_id).
  * Each related model carries its pivot row as `tag.pivot` (withPivot() adds columns, withTimestamps() the timestamps).
  */
-declare class BelongsToMany<R extends Model, P extends Model = Model> extends Relation<R, P, Collection<R>> {
+declare class BelongsToMany<R extends Model, P extends Model = Model> extends Relation<R, P, EloquentCollection<R>> {
     readonly table: string;
     readonly foreignPivotKey: string;
     readonly relatedPivotKey: string;
@@ -3675,7 +4190,7 @@ declare class BelongsToMany<R extends Model, P extends Model = Model> extends Re
     wherePivotIn(column: string, values: readonly unknown[]): this;
     /** Selects the related columns plus the pivot columns (as pivot_*), then moves those onto each model's pivot. */
     runSelect(): Promise<R[]>;
-    getResults(): Promise<Collection<R>>;
+    getResults(): Promise<EloquentCollection<R>>;
     initRelation(models: P[], relation: string): P[];
     match(models: P[], results: R[], relation: string): P[];
     getRelationExistenceQuery(query: Builder<R>, _parentQuery: Builder<P>, columns?: ColumnRef[]): Builder<R>;
@@ -3776,8 +4291,8 @@ declare abstract class HasOneOrMany<R extends Model, P extends Model, Result> ex
 }
 
 /** post.comments(): many related rows hold the parent's key. */
-declare class HasMany<R extends Model, P extends Model = Model> extends HasOneOrMany<R, P, Collection<R>> {
-    getResults(): Promise<Collection<R>>;
+declare class HasMany<R extends Model, P extends Model = Model> extends HasOneOrMany<R, P, EloquentCollection<R>> {
+    getResults(): Promise<EloquentCollection<R>>;
     initRelation(models: P[], relation: string): P[];
     match(models: P[], results: R[], relation: string): P[];
 }
@@ -3786,7 +4301,7 @@ declare class HasMany<R extends Model, P extends Model = Model> extends HasOneOr
  * Related rows reached through an intermediate model: country.posts() → hasManyThrough(Post, User):
  * posts join users on users.id = posts.user_id where users.country_id = countries.id.
  */
-declare class HasManyThrough<R extends Model, P extends Model = Model, T extends Model = Model> extends Relation<R, P, Collection<R>> {
+declare class HasManyThrough<R extends Model, P extends Model = Model, T extends Model = Model> extends Relation<R, P, EloquentCollection<R>> {
     readonly throughParent: T;
     readonly firstKey: string;
     readonly secondKey: string;
@@ -3813,8 +4328,8 @@ declare class HasManyThrough<R extends Model, P extends Model = Model, T extends
     addEagerConstraints(models: P[]): void;
     /** Selects the related columns plus the through key, then moves the key off the attributes. */
     runSelect(): Promise<R[]>;
-    getResults(): Promise<Collection<R>>;
-    getEager(): Promise<Collection<R>>;
+    getResults(): Promise<EloquentCollection<R>>;
+    getEager(): Promise<EloquentCollection<R>>;
     initRelation(models: P[], relation: string): P[];
     match(models: P[], results: R[], relation: string): P[];
     getRelationExistenceQuery(query: Builder<R>, _parentQuery: Builder<P>, columns?: ColumnRef[]): Builder<R>;
@@ -3925,6 +4440,8 @@ declare class Model implements ModelInstance {
         raw: unknown;
         value: unknown;
     }>;
+    /** Attributes with the hashed cast that were assigned a value since the last save; save() hashes them. */
+    protected pendingHashes: Set<string>;
     constructor();
     /** Runs booting()/booted() once per class, the first time the class is instantiated. */
     static bootIfNotBooted(): void;
@@ -3975,6 +4492,13 @@ declare class Model implements ModelInstance {
      * Observer classes are resolved from the container.
      */
     static observe(...observers: Array<object | (new () => object)>): void;
+    /**
+     * Turns the relation guard on or off: while it is on, reading a property of a relation method as if it were the
+     * related model (`post.author.name`) warns once with how to read the relation. DatabaseServiceProvider turns it on
+     * outside production. Turning it on again forgets which warnings were given.
+     */
+    static warnOnRelationPropertyAccess(enabled?: boolean): void;
+    static warnsOnRelationPropertyAccess(): boolean;
     /** Runs fn with model events off, for this async context only. */
     static withoutEvents<R>(fn: () => R): R;
     /** A new query of this model, with its global scopes. */
@@ -3995,6 +4519,12 @@ declare class Model implements ModelInstance {
     /** Post.whereLike('title', `%${term}%`): case-insensitive unless caseSensitive (see the query builder's whereLike()). */
     static whereLike<C extends typeof Model>(this: C, column: Column<Instance<C>> | Expression, value: string, caseSensitive?: boolean): ModelBuilder<C>;
     static whereNotLike<C extends typeof Model>(this: C, column: Column<Instance<C>> | Expression, value: string, caseSensitive?: boolean): ModelBuilder<C>;
+    /** Post.whereDate('published_at', '2026-01-05'), Post.whereDate('published_at', '<', new Date()). */
+    static whereDate<C extends typeof Model>(this: C, column: Column<Instance<C>> | Expression, ...args: DateWhereArgs): ModelBuilder<C>;
+    static whereTime<C extends typeof Model>(this: C, column: Column<Instance<C>> | Expression, ...args: DateWhereArgs): ModelBuilder<C>;
+    static whereDay<C extends typeof Model>(this: C, column: Column<Instance<C>> | Expression, ...args: DateWhereArgs): ModelBuilder<C>;
+    static whereMonth<C extends typeof Model>(this: C, column: Column<Instance<C>> | Expression, ...args: DateWhereArgs): ModelBuilder<C>;
+    static whereYear<C extends typeof Model>(this: C, column: Column<Instance<C>> | Expression, ...args: DateWhereArgs): ModelBuilder<C>;
     static whereColumn<C extends typeof Model>(this: C, first: Column<Instance<C>>, operatorOrSecond: string, second?: Column<Instance<C>>): ModelBuilder<C>;
     static whereRaw<C extends typeof Model>(this: C, sql: string, bindings?: readonly unknown[]): ModelBuilder<C>;
     static select<C extends typeof Model>(this: C, ...columns: Array<Column<Instance<C>> | Expression>): ModelBuilder<C>;
@@ -4009,6 +4539,13 @@ declare class Model implements ModelInstance {
     /** Eager loads relations: Post.with('author', 'comments.user').get(). */
     static with<C extends typeof Model>(this: C, ...relations: EagerLoadSpec[]): ModelBuilder<C>;
     static withCount<C extends typeof Model>(this: C, ...relations: EagerLoadSpec[]): ModelBuilder<C>;
+    /** Post.withSum('orders', 'price'): adds orders_sum_price. */
+    static withSum<C extends typeof Model>(this: C, relations: EagerLoadSpec | EagerLoadSpec[], column: string | Expression): ModelBuilder<C>;
+    static withAvg<C extends typeof Model>(this: C, relations: EagerLoadSpec | EagerLoadSpec[], column: string | Expression): ModelBuilder<C>;
+    static withMin<C extends typeof Model>(this: C, relations: EagerLoadSpec | EagerLoadSpec[], column: string | Expression): ModelBuilder<C>;
+    static withMax<C extends typeof Model>(this: C, relations: EagerLoadSpec | EagerLoadSpec[], column: string | Expression): ModelBuilder<C>;
+    static withExists<C extends typeof Model>(this: C, ...relations: EagerLoadSpec[]): ModelBuilder<C>;
+    static withAggregate<C extends typeof Model>(this: C, relations: EagerLoadSpec | EagerLoadSpec[], column: string | Expression, fn?: string): ModelBuilder<C>;
     static has<C extends typeof Model>(this: C, relation: string, operator?: string, count?: number): ModelBuilder<C>;
     static whereHas<C extends typeof Model>(this: C, relation: string, callback?: RelationConstraint, operator?: string, count?: number): ModelBuilder<C>;
     static doesntHave<C extends typeof Model>(this: C, relation: string): ModelBuilder<C>;
@@ -4018,11 +4555,11 @@ declare class Model implements ModelInstance {
     /** Soft deletes: only trashed rows. */
     static onlyTrashed<C extends typeof Model>(this: C): ModelBuilder<C>;
     static withoutTrashed<C extends typeof Model>(this: C): ModelBuilder<C>;
-    static all<C extends typeof Model>(this: C): Promise<Collection<Instance<C>>>;
+    static all<C extends typeof Model>(this: C): Promise<EloquentCollection<Instance<C>>>;
     static find<C extends typeof Model>(this: C, id: unknown): Promise<Instance<C> | undefined>;
-    static findOrFail<C extends typeof Model>(this: C, ids: readonly unknown[]): Promise<Collection<Instance<C>>>;
+    static findOrFail<C extends typeof Model>(this: C, ids: readonly unknown[]): Promise<EloquentCollection<Instance<C>>>;
     static findOrFail<C extends typeof Model>(this: C, id: unknown): Promise<Instance<C>>;
-    static findMany<C extends typeof Model>(this: C, ids: readonly unknown[]): Promise<Collection<Instance<C>>>;
+    static findMany<C extends typeof Model>(this: C, ids: readonly unknown[]): Promise<EloquentCollection<Instance<C>>>;
     static first<C extends typeof Model>(this: C): Promise<Instance<C> | undefined>;
     static firstOrFail<C extends typeof Model>(this: C): Promise<Instance<C>>;
     static firstWhere<C extends typeof Model>(this: C, column: Column<Instance<C>> | Expression, operatorOrValue: unknown, value?: unknown): Promise<Instance<C> | undefined>;
@@ -4032,8 +4569,8 @@ declare class Model implements ModelInstance {
     static paginate<C extends typeof Model>(this: C, perPage?: number, columns?: string[], pageName?: string, page?: number): Promise<LengthAwarePaginator<Instance<C>>>;
     static simplePaginate<C extends typeof Model>(this: C, perPage?: number, columns?: string[], pageName?: string, page?: number): Promise<Paginator<Instance<C>>>;
     static cursorPaginate<C extends typeof Model>(this: C, perPage?: number, columns?: string[], cursorName?: string, cursor?: Cursor | string): Promise<CursorPaginator<Instance<C>>>;
-    static chunk<C extends typeof Model>(this: C, count: number, callback: (models: Collection<Instance<C>>, page: number) => unknown): Promise<boolean>;
-    static chunkById<C extends typeof Model>(this: C, count: number, callback: (models: Collection<Instance<C>>, page: number) => unknown): Promise<boolean>;
+    static chunk<C extends typeof Model>(this: C, count: number, callback: (models: EloquentCollection<Instance<C>>, page: number) => unknown): Promise<boolean>;
+    static chunkById<C extends typeof Model>(this: C, count: number, callback: (models: EloquentCollection<Instance<C>>, page: number) => unknown): Promise<boolean>;
     static each<C extends typeof Model>(this: C, callback: (model: Instance<C>, index: number) => unknown, count?: number): Promise<boolean>;
     static lazy<C extends typeof Model>(this: C, chunkSize?: number): LazyCollection<Instance<C>>;
     static lazyById<C extends typeof Model>(this: C, chunkSize?: number): LazyCollection<Instance<C>>;
@@ -4077,6 +4614,8 @@ declare class Model implements ModelInstance {
     hasSetMutator(key: string): boolean;
     /** Every cast, including the implied ones: the incrementing key (int) and the timestamp columns (datetime). */
     getCasts(): Record<string, CastDefinition>;
+    /** Adds casts to this instance only (Laravel's mergeCasts()); withCasts() on a query does it for each result. */
+    mergeCasts(casts: Readonly<Record<string, CastDefinition>>): this;
     hasCast(key: string, types?: string[]): boolean;
     /** The stored attributes, with in-place changes to json casts written back. */
     getAttributes(): Row;
@@ -4174,6 +4713,14 @@ declare class Model implements ModelInstance {
      * runs no query at all. Returns false when a saving/creating/updating listener cancels.
      */
     save(): Promise<boolean>;
+    /**
+     * Laravel's hashed cast (castAttributeAsHashedString()), run when the model is saved because the Hasher is
+     * asynchronous: each newly assigned value is hashed before the saving event, so every listener sees the hash, and
+     * again just before the write (after the creating or updating event), so a value a listener assigns is hashed too.
+     * A value that is already a hash is kept when it matches the configured algorithm and options, and refused
+     * otherwise. Only strings and numbers are hashed (null stays null); any other value is refused.
+     */
+    protected hashPendingAttributes(): Promise<void>;
     /** Fills and saves an existing model. */
     update(attributes?: Row): Promise<boolean>;
     /**
@@ -4274,7 +4821,7 @@ declare class Model implements ModelInstance {
     getRelationInstance(name: string): Relation;
     /**
      * A loaded relation, typed from the relation method: post.getRelation('author') is User | null,
-     * post.getRelation('comments') is Collection<Comment>. Throws RelationNotLoadedError when it isn't loaded
+     * post.getRelation('comments') is EloquentCollection<Comment>. Throws RelationNotLoadedError when it isn't loaded
      * (JavaScript can't lazy-load synchronously: use with(), load() or post.comments().get()).
      */
     getRelation<K extends RelationNames<this>>(name: K): RelationValue<this, K>;
@@ -4284,6 +4831,20 @@ declare class Model implements ModelInstance {
     loadMissing(...relations: string[]): Promise<this>;
     /** Loads <relation>_count attributes: await post.loadCount('comments'). */
     loadCount(...relations: EagerLoadSpec[]): Promise<this>;
+    /** Loads an aggregate of a relation as an attribute (Laravel's loadAggregate()): see withAggregate(). */
+    loadAggregate(relations: EagerLoadSpec | EagerLoadSpec[], column: string | Expression, fn?: string): Promise<this>;
+    /** Loads <relation>_sum_<column>: await user.loadSum('orders', 'price'). */
+    loadSum(relations: EagerLoadSpec | EagerLoadSpec[], column: string | Expression): Promise<this>;
+    loadAvg(relations: EagerLoadSpec | EagerLoadSpec[], column: string | Expression): Promise<this>;
+    loadMin(relations: EagerLoadSpec | EagerLoadSpec[], column: string | Expression): Promise<this>;
+    loadMax(relations: EagerLoadSpec | EagerLoadSpec[], column: string | Expression): Promise<this>;
+    /** Loads a boolean <relation>_exists. */
+    loadExists(...relations: EagerLoadSpec[]): Promise<this>;
+    /**
+     * The collection queries of this model return (Laravel's newCollection()): an EloquentCollection. Override it to
+     * return a subclass with your own methods.
+     */
+    newCollection<T extends Model>(this: T, models?: T[]): EloquentCollection<T>;
     /** Stores a loaded relation (eager loading and load() use this). */
     setRelation(name: string, value: unknown): this;
     relationLoaded(name: string): boolean;
@@ -4361,13 +4922,15 @@ declare class DatabaseNotification extends DatabaseNotification_base implements
     markAsUnread(): Promise<void>;
     read(): boolean;
     unread(): boolean;
+    /** Queries of notifications return a DatabaseNotificationCollection (markAsRead() on all of them). */
+    newCollection<T extends Model>(this: T, models?: T[]): EloquentCollection<T>;
     /** `query.read()`: only read notifications. */
     static scopeRead(query: Builder<DatabaseNotification>): Builder<DatabaseNotification>;
     /** `query.unread()`: only unread notifications. */
     static scopeUnread(query: Builder<DatabaseNotification>): Builder<DatabaseNotification>;
 }
 /** Laravel's DatabaseNotificationCollection: what `await user.notifications().get()` returns. */
-declare class DatabaseNotificationCollection extends Collection<DatabaseNotification> {
+declare class DatabaseNotificationCollection extends EloquentCollection<DatabaseNotification> {
     /** Marks every notification as read (one save each, as in Laravel). */
     markAsRead(): Promise<void>;
     /** Marks every notification as unread. */
@@ -4549,6 +5112,14 @@ declare class Migrator {
     private rollDown;
     /** Runs up/down on the migration's connection (made the default meanwhile), in a transaction where DDL allows it. */
     private runMigration;
+    /**
+     * SQLite's order for a migration in a transaction: foreign keys off before the transaction (SQLite ignores the pragma
+     * inside one, and a table rebuild would otherwise run the ON DELETE actions of the tables that reference it), the
+     * migration, a foreign key check before the commit (rows that break a key fail the migration), then foreign keys back
+     * on. A migration outside a transaction runs with foreign keys as they are, so its ON DELETE and ON UPDATE actions
+     * run; a table rebuild in it turns them off around itself and checks the table.
+     */
+    private runOnSqlite;
 }
 
 type SeederClass = new () => Seeder;
@@ -4781,34 +5352,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;
@@ -4830,6 +5405,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>;
@@ -4843,6 +5429,11 @@ interface BuiltinRule {
     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';
@@ -4852,8 +5443,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 {
@@ -4866,8 +5467,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[];
@@ -4881,8 +5482,14 @@ declare const builtinRules: Record<string, BuiltinRule>;
  * Rule.password() returns the application default (PasswordRule.defaults()). (Laravel's uncompromised() is not
  * ported: it calls an outside service.)
  */
-declare class PasswordRule implements ValidationRule {
+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;
@@ -4902,7 +5509,7 @@ declare class PasswordRule implements ValidationRule {
     numbers(): this;
     /** At least one symbol (punctuation, a symbol or a space). */
     symbols(): this;
-    validate(attribute: string, value: unknown, fail: (message: string) => void): void;
+    validate(_attribute: string, value: unknown, fail: (message: string) => void): void;
 }
 
 /**
@@ -4911,17 +5518,121 @@ declare class PasswordRule implements ValidationRule {
  * ("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;
     private readonly column?;
@@ -4948,34 +5659,38 @@ 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;
     /** Laravel's Password::defaults(): the application's password rule (at least 8 characters unless PasswordRule.defaults() changed it). */
     password: () => PasswordRule;
 };
 
-/** 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;
-};
-
 /**
  * Runs each field's rules the way Laravel's Validator does:
  * - a missing key, or a string that is blank after trimming, only runs implicit rules (the required* family and
@@ -4985,7 +5700,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;
@@ -4995,16 +5710,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;
@@ -5012,7 +5751,7 @@ 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>;
     extend(name: string, callback: RuleCallback, message?: string): void;
 }
 
@@ -5231,7 +5970,7 @@ declare class CookieJar implements CookieJar$1 {
     #private;
     constructor(defaults?: CookieDefaults);
     make(name: string, value: string, minutes?: number, options?: CookieOptions): Cookie$1;
-    /** Five years, like Laravel. */
+    /** 400 days, as in Laravel: the longest lifetime browsers keep a cookie. */
     forever(name: string, value: string, options?: CookieOptions): Cookie$1;
     /** An expired cookie that makes the browser delete it. */
     forget(name: string, options?: CookieOptions): Cookie$1;
@@ -5516,12 +6255,13 @@ declare class VerifyCsrfToken implements Middleware {
 }
 
 /**
- * A read-only MessageBag over one bag of the flashed validation errors. Http flashes
+ * A MessageBag over one bag of the flashed validation errors (add() changes this bag, not the session). Http flashes
  * `errors: { [bag]: { field: string[] } }`; views read them with `errors().first('email')`.
  */
 declare class SessionMessageBag implements MessageBag {
     #private;
     constructor(messages?: Record<string, string[]>);
+    add(key: string, message: string): void;
     has(key: string): boolean;
     first(key?: string): string | undefined;
     get(key: string): string[];
@@ -5695,7 +6435,7 @@ declare class SendEmailVerificationNotification {
  */
 declare class EmailVerificationRequest {
     static validate(): Promise<Record<string, never>>;
-    authorize(): boolean;
+    authorize(): Promise<boolean>;
     rules(): Record<string, never>;
     /** Marks the signed-in user's email as verified and fires Verified, unless it already was. */
     fulfill(): Promise<void>;
@@ -5785,8 +6525,6 @@ declare class SessionGuard implements StatefulGuard {
     private readonly options;
     constructor(name: string, provider: UserProvider, container: Container$1, options?: SessionGuardOptions);
     user<T extends Authenticatable = Authenticatable>(): Promise<T | undefined>;
-    /** The user already resolved in this request, without touching the provider (used by request.user()). */
-    currentUser(): Authenticatable | undefined;
     id(): Promise<unknown>;
     check(): Promise<boolean>;
     guest(): Promise<boolean>;
@@ -5931,8 +6669,6 @@ declare class TokenGuard implements Guard {
     private readonly options;
     constructor(name: string, provider: UserProvider, container: Container$1, tokens: TokenRepository, options?: TokenGuardOptions);
     user<T extends Authenticatable = Authenticatable>(): Promise<T | undefined>;
-    /** The user already resolved in this request (used by request.user()). */
-    currentUser(): Authenticatable | undefined;
     /** The token the request authenticated with. */
     currentAccessToken(): PersonalAccessToken | undefined;
     id(): Promise<unknown>;
@@ -5950,7 +6686,7 @@ declare class TokenGuard implements Guard {
  * sessions in one file.
  */
 declare const USERS_TABLE_MIGRATION = "import { Migration, Schema } from '@orieljs/framework'\n\nexport default class extends Migration {\n  async up() {\n    await Schema.create('users', (t) => {\n      t.id()\n      t.string('name')\n      t.string('email').unique()\n      t.timestamp('email_verified_at').nullable()\n      t.string('password')\n      t.rememberToken()\n      t.timestamps()\n    })\n\n    await Schema.create('password_reset_tokens', (t) => {\n      t.string('email').primary()\n      t.string('token')\n      t.timestamp('created_at').nullable()\n    })\n\n    await Schema.create('sessions', (t) => {\n      t.string('id').primary()\n      t.foreignId('user_id').nullable().index()\n      t.string('ip_address', 45).nullable()\n      t.text('user_agent').nullable()\n      t.longText('payload')\n      t.integer('last_activity').index()\n    })\n  }\n\n  async down() {\n    await Schema.dropIfExists('users')\n    await Schema.dropIfExists('password_reset_tokens')\n    await Schema.dropIfExists('sessions')\n  }\n}\n";
-/** Sanctum's create_personal_access_tokens_table (written by install:api). */
+/** Sanctum's create_personal_access_tokens_table, as new apps ship it in database/migrations. */
 declare const PERSONAL_ACCESS_TOKENS_MIGRATION = "import { Migration, Schema } from '@orieljs/framework'\n\nexport default class extends Migration {\n  async up() {\n    await Schema.create('personal_access_tokens', (t) => {\n      t.id()\n      t.morphs('tokenable')\n      t.string('name')\n      t.string('token', 64).unique()\n      t.text('abilities').nullable()\n      t.timestamp('last_used_at').nullable()\n      t.timestamp('expires_at').nullable()\n      t.timestamps()\n    })\n  }\n\n  async down() {\n    await Schema.dropIfExists('personal_access_tokens')\n  }\n}\n";
 
 /** Laravel's Illuminate\Auth\Access\Response: what an ability or policy method may return instead of a boolean. */
@@ -6831,6 +7567,13 @@ declare class RedisRepository extends Repository {
     private readonly redisStore;
     private readonly redis;
     constructor(redisStore: RedisStore, redis: Redis$1);
+    /**
+     * Closes the redis client (CacheManager.disconnectAll() at shutdown): a connected one with QUIT, one that never
+     * connected or is reconnecting without waiting; one already closed is left alone. A client two stores share is quit
+     * once: QUIT resolves on the server's reply, but the client reads 'ready' until its socket closes, so the second
+     * store waits on the first one's QUIT instead of sending another (which would fail with "Connection is closed.").
+     */
+    disconnect(): Promise<void>;
     tags(names: string | string[]): CacheRepository;
 }
 
@@ -6846,6 +7589,12 @@ declare class CacheManager implements CacheManager$1 {
     private buildDatabaseStore;
     private buildRedisStore;
     store(name?: string): CacheRepository;
+    /**
+     * Closes the redis clients of the stores resolved so far and forgets the stores, so the next use builds them again
+     * (the app's shutdown calls it). Stores without a connection to close are only forgotten. A store that fails to
+     * close doesn't keep the others open: all are closed, then its error is thrown (several: an AggregateError).
+     */
+    disconnectAll(): Promise<void>;
     extend(driver: string, factory: Driver$1): void;
     get<T = unknown>(key: string, defaultValue?: T | (() => T)): Promise<T | undefined>;
     many<T = unknown>(keys: string[]): Promise<Record<string, T | undefined>>;
@@ -7037,6 +7786,8 @@ interface S3ClientLike {
 }
 interface S3DiskConfig {
     bucket: string;
+    /** The bucket's region, for `url()`'s host. Default: us-east-1, as the client's. */
+    region?: string;
     /** Public base URL for `url()`, e.g. a CloudFront domain. Falls back to the S3 virtual-hosted URL. */
     url?: string;
     endpoint?: string;
@@ -7071,6 +7822,12 @@ declare class S3Filesystem implements Filesystem {
     size(path: string): Promise<number>;
     lastModified(path: string): Promise<Date>;
     mimeType(path: string): Promise<string | undefined>;
+    /**
+     * The object's public URL, as the SDK builds it (Flysystem's getObjectUrl()): the key encoded, on the configured
+     * `url`, else on the endpoint or the region's S3 host, with the bucket as a subdomain or, path-style, in the path.
+     * Laravel leaves the key unencoded on a configured `url`; here it is encoded there too. Only the join onto a
+     * configured `url` trims a leading slash, as Laravel does; elsewhere the key is kept as `put()` stores it.
+     */
     url(path: string): string;
     temporaryUrl(path: string, expiresAt: Date): Promise<string>;
     files(directory?: string, recursive?: boolean): Promise<string[]>;
@@ -7632,6 +8389,10 @@ declare class Worker {
     /** F2: the promise handling the most recently leaked unhandled rejection, awaited by process() before it decides
      *  whether the job succeeded, so failing it is never racing the "processed" event. */
     private pendingRejection;
+    /** Laravel's $lastRestart: the restart flag when the daemon started, or UNREAD while the cache can't be read. */
+    private lastRestart;
+    /** Whether the last read of the restart flag failed, so an outage is reported once rather than after every job. */
+    private restartFlagFailing;
     constructor(manager: QueueManager$1, container: Container$1, listener?: WorkerListener);
     /** Runs until a stop condition; returns the exit code. `queue` may be a comma-separated priority list. */
     daemon(connectionName: string, queue: string, options: WorkerOptions): Promise<number>;
@@ -7664,7 +8425,13 @@ declare class Worker {
     private calculateBackoff;
     private stopIfNecessary;
     memoryExceeded(limitMb: number): boolean;
+    /**
+     * Laravel's queueShouldRestart(), except that a cache that fails doesn't stop the worker: while the flag can't be
+     * read the worker keeps going, and when it couldn't be read at start, the first value read becomes the baseline,
+     * so a queue:restart broadcast after that still stops it.
+     */
     private queueShouldRestart;
+    /** The restart flag, or UNREAD when the cache fails (reported once per outage, never thrown). */
     private getTimestampOfLastQueueRestart;
     /** Reports through the ExceptionHandler when bound, and tells the listener. Never throws. */
     private report;
@@ -7801,6 +8568,12 @@ declare const QUEUE_JOB: unique symbol;
 declare const CHAIN: unique symbol;
 /** The unique-lock spec set after acquiring the lock; Queue copies it to payload.uniqueLock and releases it. */
 declare const UNIQUE_LOCK: unique symbol;
+/**
+ * The uniqueness of the class a wrapper job runs (a queued mailable, notification or listener), set on the wrapper by
+ * Mail, Notifications and Events, which can't import Bus. isUnique() and UniqueLock read it instead of the job's own
+ * members; being symbol-keyed it never reaches the payload (the lock itself travels as payload.uniqueLock).
+ */
+declare const UNIQUE: unique symbol;
 interface ChainSpec {
     jobs: Job[];
     connection?: string;
@@ -7812,16 +8585,37 @@ interface UniqueLockSpec {
     store?: string;
     untilProcessing: boolean;
 }
+/** What a wrapper carries under UNIQUE: the lock is `oriel_unique_job:<name>:<id>`. */
+interface UniqueSpec {
+    /** The wrapped class, as the job's displayName(): `OrderShipped`, not `SendQueuedMailable`. */
+    name: string;
+    /** The wrapped object's uniqueId(), '' when it has none (one at a time per class, as Laravel). */
+    id: string;
+    /** uniqueFor in seconds; 0 or none means the lock lasts until the job is done. */
+    for?: number;
+    /** uniqueUntilProcessing: the lock goes when the job starts rather than when it is done. */
+    untilProcessing?: boolean;
+    /** uniqueVia(): the cache store holding the lock. */
+    via?: string;
+}
 /**
  * Whether dispatch() queues the job: it carries ShouldQueue's `shouldQueue: true` (a `readonly shouldQueue = true`
  * field, or the Queueable base class's getter), the SHOULD_QUEUE symbol, a value for any ShouldQueue option, or
  * defines uniqueId()/retryUntil().
  */
 declare function isQueueable(job: unknown): boolean;
-/** Laravel's ShouldBeUnique: the job defines uniqueId(), uniqueFor, uniqueUntilProcessing or uniqueVia(). */
+/**
+ * Laravel's ShouldBeUnique: the job defines uniqueId(), uniqueFor, uniqueUntilProcessing or uniqueVia(), or carries
+ * the UNIQUE spec of the class it wraps.
+ */
 declare function isUnique(job: unknown): boolean;
+/** Seconds from a delay given as seconds or a Date (here rather than in Dispatcher.ts, so PendingBatch needs no cycle). */
+declare function delaySeconds(delay: unknown): number;
 
-/** Laravel's UniqueLock. The lock lives in `uniqueVia()`'s cache store (a store name) or the default store. */
+/**
+ * Laravel's UniqueLock. The lock lives in `uniqueVia()`'s cache store (a store name) or the default store. A wrapper
+ * job (queued mail, notification or listener) is locked under the class it wraps, from its UNIQUE spec.
+ */
 declare class UniqueLock {
     private readonly cache;
     constructor(cache: CacheManager$1);
@@ -7836,7 +8630,7 @@ declare class UniqueLock {
     private store;
 }
 
-/** Bus.batch([...]): stores the batch, then queues every job with its batchId. */
+/** Bus.batch([...]): stores the batch, then queues every job with its batchId (and its own delay). */
 declare class PendingBatch implements PendingBatch$1 {
     private readonly container;
     private readonly jobs;
@@ -7865,8 +8659,6 @@ declare class PendingBatch implements PendingBatch$1 {
     dispatch(): Promise<Batch$1>;
 }
 
-/** Seconds from a delay given as seconds or a Date. */
-declare function delaySeconds(delay: unknown): number;
 /** Laravel's Illuminate\Bus\Dispatcher. */
 declare class Dispatcher implements BusDispatcher {
     #private;
@@ -8155,7 +8947,8 @@ declare const QueuedMailSender: Token<QueuedMailSender>;
  * Carries `SHOULD_QUEUE` on its own prototype, per the Queue/Bus protocol, so `BusDispatcher.dispatch()` — which
  * re-decides queued-or-now on whatever job it's handed — actually enqueues it instead of running it inline; the
  * mailable's own queueability (checked by MailerImpl) only decides whether to wrap it at all. Like Laravel's
- * SendQueuedMailable, it forwards failed(), retryUntil(), middleware() and displayName() to the mailable.
+ * SendQueuedMailable, it forwards failed(), retryUntil(), middleware() and displayName() to the mailable. Unlike
+ * Laravel's, it is unique when the mailable is (Laravel pushes a mailable straight to the queue, past the unique lock).
  */
 declare class SendQueuedMailable implements Job {
     readonly mailerName: string | undefined;
@@ -8556,9 +9349,28 @@ declare class EncryptHistory implements Middleware {
     handle(request: HttpRequest, next: Next$1): Promise<Response>;
 }
 
+/** Laravel's $request->isPrecognitive(): this request only asks whether its data would pass (a `precognitive` route). */
+declare function isPrecognitive(request: HttpRequest): boolean;
+/**
+ * Laravel's HandlePrecognitiveRequests (the `precognitive` alias): a request with `Precognition: true` (Inertia's
+ * `useForm().validate()`, `<Form validate>`, laravel-precognition) runs the route's action only up to its validation.
+ * Passing answers 204 with `Precognition-Success: true`; failing, the usual 422 with the errors; and nothing after the
+ * validation runs. `Precognition-Validate-Only: name,email` checks those fields only. Every response varies on
+ * `Precognition`, an error's too: the middleware renders what is thrown through it before adding its headers.
+ *
+ * Oriel validates inside the action (`await StoreUserRequest.validate()`, `request().validate({…})`), where Laravel
+ * resolves the FormRequest before calling it, so a precognitive route must validate before it changes anything: what
+ * comes before the validation runs. An action that answers a success without validating is an error (a 500) on any
+ * method but GET and HEAD, which answer 204 as Laravel does; a redirect or an error goes through as it is.
+ */
+declare class HandlePrecognitiveRequests implements Middleware {
+    handle(request: HttpRequest, next: Next$1): Promise<Response>;
+}
+
 /**
  * Binds the Inertia factory (one root factory, plus a scoped child per request), the SSR gateway and the
- * `inertia.encrypt` middleware alias, merges config/inertia defaults and registers the inertia:* commands.
+ * `inertia.encrypt` and `precognitive` middleware aliases, merges config/inertia defaults and registers the inertia:*
+ * commands.
  */
 declare class InertiaServiceProvider extends ServiceProvider$1 {
     register(): void;
@@ -8698,4 +9510,4 @@ type SharedPropsFrom<M> = M extends {
     share(...args: never[]): infer R;
 } ? SerializedObject<Awaited<R>> : Record<never, never>;
 
-export { API_ROUTES_STUB, AboutCommand, AbstractPaginator, AccessGate, AddQueuedCookiesToResponse, type AfterCallback, AllMailersFailedError, AlwaysProp, AnonymousNotifiable, Application, ApplicationBuilder, ArgonHasher, type ArgonOptions, type ArgumentDefinition, ArraySessionHandler, ArrayTransport, Artisan, Attempting, type Attributes$1 as Attributes, type AttributesResolver, Auth, AuthManager, type AuthModel, type AuthModelBase, type AuthModelConstructor, AuthServiceProvider, AuthenticatableModel, Authenticate, AuthenticationError, Authorizable, type AuthorizableConstructor, AuthorizationError, AuthorizationErrorImpl, Authorize, BaseJob, BaseLogger, BasePipeline, BaseRouter, BaseUrlGenerator, Batch, type BatchAttributes, BatchingUnavailableError, BcryptHasher, type BcryptOptions, type BeforeCallback, BelongsTo, BelongsToMany, BindingResolutionError, Blueprint, type BlueprintCommand, BufferedConsoleOutput, Builder, type BuiltInCast, type BuiltinRule, BuiltinRuleObject, type BunDatabase, BunSqliteDatabase, type BunStatement, Bus, Dispatcher as BusDispatcherImpl, BusError, BusServiceProvider, CACHE_TABLE_MIGRATION, CHAIN, Cache, CacheManager, CacheRateLimiter, Repository as CacheRepositoryImpl, CacheServiceProvider, type Store as CacheStore, CallQueuedHandler, CallQueuedListener, type CanResetPassword, type CanResetPasswordUser, type CastDefinition, type CastsAttributes, type ChainSpec, type CipherName, CircularDependencyError, ClosureCommand, ClosureKernel, Collection, type Column, type ColumnAttributes, ColumnDefinition, type ColumnInfo, type ColumnRef, type ColumnType, Command, CommandNotFoundError, ComponentNotFoundError, Connection, type ConsoleInput, type ConsoleIo, Kernel as ConsoleKernelImpl, type ConsoleOutput, ConsoleServiceProvider, Container, ContainerNotAvailableError, Controller, ControllerMethodNotFoundError, ConvertEmptyStringsToNull, Cookie, type CookieDefaults, CookieJar, CookieServiceProvider, CookieSessionHandler, CookieValuePrefix, type CreateMigrationOptions, Crypt, Cursor, type CursorPage, CursorPaginator, type CursorPaginatorOptions, DB, DEFAULT_MESSAGES, DailyRotatingStream, DatabaseBatchRepository, type DatabaseCommandContext, type DatabaseConfig, DatabaseConfigError, DatabaseError, DatabaseFailedJobProvider, DatabaseJob, type DatabaseJobRecord, DatabaseLock, DatabaseManagerImpl, DatabaseNotification, DatabaseNotificationChannel, DatabaseNotificationCollection, DatabaseNotificationsRelation, DatabaseQueue, type DatabaseQueueOptions, DatabaseServiceProvider, DatabaseSessionHandler, DatabaseStore, DatabaseTokenRepository, DatabaseUnavailableError, DecryptError, DeferProp, DiagnosingHealth, type Direction, Dispatchable, type EagerLoadSpec, EloquentUserProvider, EmailVerificationRequest, type Encoded, EncryptCookies, EncryptError, EncryptHistory, Encrypter, EncryptionServiceProvider, EnsureEmailIsVerified, type EnumLike, type ErrorClass, ErrorHandler, Event, Dispatcher$1 as EventDispatcherImpl, type EventKey, type EventListenMap, EventServiceProvider, EventsNeedBusDispatcherError, EventsNeedClassRegistryError, ExceptionsConfiguration, Expression, Facade, Factory, type FactoryResult, Failed, FailoverTransport, Faker, FakerOverflowError, FileNotFoundError, FileSessionHandler, FileStore, FilesystemManager, FilesystemServiceProvider, ForeignIdColumnDefinition, ForeignKeyDefinition, FormRequest, FormUploadedFile, Gate, type GateAbility, GateResponse, GeneratorCommand, GenericLock, type GlobalScope, Grammar, type GroupAttributes, type GroupHost, GroupRegistrar, type GuardFactory, HasApiTokens, HasDatabaseNotifications, type HasDatabaseNotificationsModel, type HasFactory, HasMany, HasManyThrough, HasOne, HasOneOrMany, HasUlids, HasUuids, Hash, HashAlgorithmError, type HashInfo, HashManager, type HasherFactory, type HashingConfig, HashingServiceProvider, type Having, type HealthPage, HelpCommand, type HttpCommandOptions, HttpException, Kernel$1 as HttpKernelImpl, HttpRedirectResponse, HttpRedirector, HttpResponseException, HttpResponseFactory, HttpServerError, HttpServiceProvider, Hub, IncomingRequest, type IncomingRequestOptions, type IndexType, Inertia, InertiaError, InertiaHtml, InertiaMiddleware, InertiaPage, Response$1 as InertiaPageResponse, ResponseFactory as InertiaResponseFactory, InertiaServiceProvider, type ValidationErrors as InertiaValidationErrors, type InferRuleType, type InferValidatedType, InvalidCacheConfigError, InvalidCastError, InvalidListenerError, InvalidLogLevelError, InvalidRuleParameterError, InvalidSignatureError, InvalidUrlSignatureError, JOBS_TABLE_MIGRATION, JobClassNotFoundError, type JobContext, type JobMiddleware, JobSerializationError, JoinClause, type JoinType, type JsonWhenCallback, KEY_GENERATE_SIGNATURE, type KernelApp, type KeyGenerateIO, LEVEL_SEVERITY, LazyCollection, type LengthAwarePage, LengthAwarePaginator, ListCommand, type ListenerTuple, type LocalDiskConfig, LocalFilesystem, type LockFactory, LockTimeoutError, Lockout, Log, LogChannelCycleError, LogManager, LogServiceProvider, LogTransport, type LoggedQuery, LogicError, Login, Logout, MIGRATION_CREATE_STUB, MIGRATION_STUB, MIGRATION_UPDATE_STUB, MODEL_EVENTS, Mail, MailManager, MailMessage, type MailMessageAction, MailNotificationChannel, MailQueueUnavailableError, MailServiceProvider, type MailTransporter, MailUnavailableError, Mailable, MailerImpl, MakeCastCommand, MakeCommandCommand, MakeControllerCommand, MakeEventCommand, MakeFactoryCommand, MakeJobCommand, MakeListenerCommand, MakeMailCommand, MakeMiddlewareCommand, MakeModelCommand, MakeNotificationCommand, MakeObserverCommand, MakePolicyCommand, MakeProviderCommand, MakeRequestCommand, MakeResourceCommand, MakeRuleCommand, MakeSeederCommand, MakeTestCommand, type Manifest, type ManifestChunk, ManuallyFailedError, type Many, MassAssignmentError, MaxAttemptsExceededError, MemoryStore, MergeProp, MessageBagImpl, MethodNotAllowedHttpError, MiddlewareConfiguration, MiddlewareNotFoundError, Migration, MigrationCreator, type MigrationRecord, MigrationRepository, type MigrationStatus, Migrator, type MigratorOptions, MissingAppKeyError, MissingModelError, MissingRecipientError, Model, type ModelBuilder, type ModelClass, type ModelConstructor, type ModelEvent, type ModelListener, ModelNotFoundError, ModelRegistry, type MorphConstraint, MorphMany, MorphOne, MorphTo, MySqlSchemaGrammar, NOTIFICATIONS_TABLE, NOTIFICATIONS_TABLE_MIGRATION, type NewAccessToken, NodeConsoleInput, NodeConsoleOutput, NotDatabaseNotifiableError, NotFoundHttpError, Notifiable, type NotifiableConstructor, Notification, Dispatcher$2 as NotificationDispatcherImpl, NotificationDispatcherUnavailableError, NotificationFacade, NotificationQueueUnavailableError, NotificationsServiceProvider, NullFailedJobProvider, NullLogger, NullQueue, OPERATORS, OnceProp, type OptionDefinition, OptionValue, OptionalProp, type Order, PERSONAL_ACCESS_TOKENS_MIGRATION, type PagePropsFrom, type PaginationLink, Paginator, type PaginatorOptions, type ParsedInput, type ParsedRule, type ParsedSetCookie, type ParsedSignature, Password, PasswordBroker, PasswordBrokerManager, PasswordReset, PasswordRule, PathTraversalError, PendingBatch, PendingChain, PendingDispatch, PersonalAccessToken, PinoLogger, PipelineError, PipelineServiceProvider, Pivot, type PivotIds, type PlainNotificationMail, type PolicyClass, PostgresSchemaGrammar, type PreloadAttributesResolver, PropsResolver, ProviderBootError, ProviderRegisterError, QUEUE_JOB, Builder$1 as QueryBuilder, QueryError, Queue, QueueBase, type QueueCommandContext, QueueError, type QueueJobPayload, Listener as QueueListener, type ListenerConfig as QueueListenerConfig, type ListenerOptions as QueueListenerOptions, type ListenerOutput as QueueListenerOutput, QueueManager, QueueServiceProvider, QueueUnavailableError, Queueable, QueuedConsoleInput, QueuedMailSender, type QueuedMailableFactory, RESTART_CACHE_KEY, RateLimiter, type RawResult, type RecipientOverrides, RedirectIfAuthenticated, RedisJob, RedisLock, RedisQueue, type RedisQueueOptions, RedisRepository, type RedisSessionClient, RedisSessionHandler, RedisStore, RedisTaggedStore, type ReferentialAction, Registered, type RegisteredModel, Relation, type RelationConstraint, type RelationNames, RelationNotFoundError, RelationNotLoadedError, type RelationValue, type RenderCallback, type RenderedContent, type ReplStarter, type ReportCallback, Repository$1 as Repository, ResetPassword, type ResetPasswordMail, type ResolvedMiddleware, type ResolvedServeOptions, type ResourceMethod, type ResourceRoute, type RollbackOptions, Route, type RouteAttributes, type RouteBinder, RouteDefinition, type RouteFileCallback, type RouteHandler, type RouteListFilters, type RouteListRow, RouteModelNotFoundError, RouteModelResolverImpl, RouteName, RouteNotDefinedError, type RouteStage, RoutesNotifications, RoutingError, type RoutingOptions, RoutingServiceProvider, Rule, type RuleContext, type RunningServer, type Runtime, type S3ClientLike, type S3DiskConfig, S3Filesystem, SSR_RENDER_FAILED, STORAGE_LINK_SIGNATURE, Schedule, ScheduleClearCacheCommand, ScheduleImpl, ScheduleListCommand, ScheduleNameRequiredError, ScheduleRunCommand, ScheduleWorkCommand, type ScheduleWorkOptions, ScheduledEventImpl, Schema, SchemaBuilder, SchemaBuilderToken, SchemaGrammar, type Scope, type ScopeCallback, type ScopeStatic, type Scopes, type ScrollMetadata, ScrollProp, Seeder, type SeederClass, type SelectColumn, SendEmailVerificationNotification, SendQueuedMailable, SendQueuedNotifications, type Serialized, type SerializedObject, type ServeOptions, ServiceProvider$1 as ServiceProvider, SessionFacade as Session, type SessionConfig, SessionGuard, type SessionGuardOptions, type SessionHandlerFactory, SessionManager, SessionMessageBag, SessionServiceProvider, Store$1 as SessionStore, type SharedPropsFrom, type SimplePage, type SmtpConfig, SmtpTransport, SoftDeletingScope, type SpawnResult, type SpawnWorker, type Spawner, SqliteSchemaGrammar, SsrError, type SsrFailure, HttpGateway as SsrHttpGateway, type StackFrame, StackLogger, StartSession, type State, type StateContext, Storage, type StoredBatchOptions, type StringPipeResolver, Stringable, type SyncChanges, SyncJob, SyncQueue, type TagAttributes, TagsNotSupportedError, TestCommand, ThrottleRequests, ThrottleRequestsError, TimeoutExceededError, TinkerCommand, type TinkerOptions, type TinkerRepl, TokenGuard, type TokenGuardOptions, TokenMismatchError, TokenRepository, type TransporterFactory, TrimStrings, TypeGenerator, type TypeGeneratorOptions, type TypedRedirector, UNIQUE_LOCK, USERS_TABLE_MIGRATION, UniqueJobsNeedCacheError, UniqueLock, type UniqueLockSpec, UnknownCacheDriverError, UnknownCacheStoreError, UnknownDiskError, UnknownFilesystemDriverError, UnknownLogChannelError, UnknownLogDriverError, UnknownMailTransportError, UnknownMailerError, UnknownNotificationChannelError, UnknownQueueConnectionError, UnknownQueueDriverError, UnknownValidationRuleError, UnrenderableNotificationDataError, UnrenderableNotificationMailError, UnsupportedCipherError, UnsupportedOperationError, type UriParameter, UrlGenerationError, type UrlResolver, type UserProviderFactory, ValidateSignature, Validated, ValidationErrorImpl, ValidationException, ValidationFactoryImpl, ValidationServiceProvider, Validator, ValidatorImpl, type VerifiableUser, Verified, VerifyCsrfToken, VerifyEmail, type VerifyEmailMail, ViewFactoryUnavailableError, Vite, ViteError, ViteHtml, WORKER_DISCOVERY_DIRECTORIES, type Where, type WhereArgs, type WhereBoolean, WithoutOverlapping, Worker, type WorkerListener, type WorkerOptions, abort, abortIf, abortUnless, addApiRouting, allowGuests, applyExceptionCallbacks, applyMiddlewareCallbacks, applyReplacements, auth, back, bcrypt, builtinRules, bunRuntime, cache, castGet, castSet, classNameOf, clientAddress, columnKey, compareRoutes, contentDisposition, cookie, createDailyChannel, createDialect, createPayload, createSingleChannel, createStderrChannel, createToken, csrfToken, currentContainer, currentLogContext, currentRequest, currentVite, databaseConfigDefaults, debugPage, decodePayload, decrypt, defaultAttributeName, defaultListenerOptions, defaultLockFactory, defaultProviders, defaultWorkerOptions, delaySeconds, describeError, deserialize, detectRuntime, discoverClasses, discoverFactories, discoverJobs, discoverListeners, discoverPolicies, dispatch, dispatchRoute, dispatchSync, encodePayload, encrypt, enumValues, env, errorBagFrom, errors, escapeHtml, event, exceedsJsonDepth, expandWildcardKeys, extensionFromMime, fake, filterRouteList, formatAddress, formatDate, formatDateTime, formatRouteList, formatTimestamp, fromEntries, generateAppKey, generateModelTypes, getMorphAlias, getMorphedModel, guessTable, hashInfo, healthResponse, inertia, inertiaBody, inertiaHead, inject, ipMatches, isBlank, isBun, isDateCast, isEmptyValue, isEquivalent, isJsonCast, isListenerClass, isListenerTuple, isModel, isQueueable, isQueueableListener, isUnique, isUploadedFileLike, joinDiskPath, keyGenerateHandler, listenerOptionsFrom, loadRelations, loadRoutesFrom, logger, makeFailedJobProvider, meetsLevel, mergeGroup, mergeLogContext, mergeRecursive, migrationDatePrefix, minimalPage, modelEventName, morphMap, normalizeAddress, normalizeAddresses, normalizeBackoff, normalizeLists, normalizePath, normalizeUri, old, openSqlite, optionalCookieJar, optionalSession, orderForBindings, parseArgv, parseBracketKey, parseCookieHeader, parseDateTime, parseKey, parseParameters, parseRuleSpec, parseSignature, passwordVerify, prepareValue, queueConfigDefaults, queueOptionsOf, raw as rawSql, rawWithBindings, redirect, registerHttpCommands, registerKeyGenerateCommand, registerMigrationCommands, registerModelTypesCommand, registerQueueCommands, registerStorageLinkCommand, renderContent, renderError, request, requestScope, resolveArguments, resolveDiskPath, resolveMiddleware, resolveMorphClass, resolveOptions, resourceRoutes, response, restoreJob, restoreValue, roundTrip, route, routeListRows, runConsole, runConsoleAndExit, runMiddleware, runSeeder, sanitize, sendEmailVerificationUsing, sendNotification, serialize, serializeContext, serializeCookie, serializeDate, serializeValue, serve, serveBun, serveNode, servePublicFile, session, setClientAddress, stackFrames, statusFor, statusText, storageLinkHandler, substituteBindings, suggest, summarizeValidation, toNotifiableList, toResponse, toWebRequest, tokenableType, transformLeaves, url, usePaginationResolvers, validateRequiredArguments, vite, viteReactRefresh, withHeaders, workerOptionsFrom, writeResponse };
+export { API_ROUTES_STUB, AboutCommand, AbstractPaginator, AccessGate, AddQueuedCookiesToResponse, type AfterCallback, AllMailersFailedError, AlwaysProp, AnonymousNotifiable, Application, ApplicationBuilder, ArgonHasher, type ArgonOptions, type ArgumentDefinition, ArraySessionHandler, ArrayTransport, Artisan, Attempting, type Attributes$1 as Attributes, type AttributesResolver, Auth, AuthManager, type AuthModel, type AuthModelBase, type AuthModelConstructor, AuthServiceProvider, AuthenticatableModel, Authenticate, AuthenticationError, Authorizable, type AuthorizableConstructor, AuthorizationError, AuthorizationErrorImpl, Authorize, BaseJob, BaseLogger, BasePipeline, BaseRouter, BaseUrlGenerator, Batch, type BatchAttributes, BatchingUnavailableError, BcryptHasher, type BcryptOptions, type BeforeCallback, BelongsTo, BelongsToMany, BindingResolutionError, Blueprint, type BlueprintCommand, BufferedConsoleOutput, Builder, type BuiltInCast, type BuiltinRule, BuiltinRuleObject, type BunDatabase, BunSqliteDatabase, type BunStatement, Bus, Dispatcher as BusDispatcherImpl, BusError, BusServiceProvider, CACHE_TABLE_MIGRATION, CHAIN, Cache, CacheManager, CacheRateLimiter, Repository as CacheRepositoryImpl, CacheServiceProvider, type Store as CacheStore, CallQueuedHandler, CallQueuedListener, type CanResetPassword, type CanResetPasswordUser, type CastDefinition, type CastsAttributes, type ChainSpec, type CipherName, CircularDependencyError, ClosureCommand, ClosureKernel, Collection, type Column, type ColumnAttributes, ColumnDefinition, type ColumnInfo, type ColumnRef, type ColumnType, Command, CommandNotFoundError, ComponentNotFoundError, Config, Connection, type ConsoleInput, type ConsoleIo, Kernel as ConsoleKernelImpl, type ConsoleOutput, ConsoleServiceProvider, Container, ContainerNotAvailableError, Controller, ControllerMethodNotFoundError, ConvertEmptyStringsToNull, Cookie, type CookieDefaults, CookieJar, CookieServiceProvider, CookieSessionHandler, CookieValuePrefix, type CreateMigrationOptions, Crypt, Cursor, type CursorPage, CursorPaginator, type CursorPaginatorOptions, DB, DEFAULT_MESSAGES, DailyRotatingStream, DatabaseBatchRepository, type DatabaseCommandContext, type DatabaseConfig, DatabaseConfigError, DatabaseError, DatabaseFailedJobProvider, DatabaseJob, type DatabaseJobRecord, DatabaseLock, DatabaseManagerImpl, DatabaseNotification, DatabaseNotificationChannel, DatabaseNotificationCollection, DatabaseNotificationsRelation, DatabaseQueue, type DatabaseQueueOptions, DatabaseServiceProvider, DatabaseSessionHandler, DatabaseStore, DatabaseTokenRepository, DatabaseUnavailableError, type DatePart, type DateWhereArgs, type DateWhereValue, DecryptError, DeferProp, DiagnosingHealth, type Direction, Dispatchable, type EagerLoadSpec, EloquentCollection, EloquentUserProvider, EmailVerificationRequest, type Encoded, EncryptCookies, EncryptError, EncryptHistory, Encrypter, EncryptionServiceProvider, EnsureEmailIsVerified, type EnumLike$1 as EnumLike, type ErrorClass, ErrorHandler, Event, Dispatcher$1 as EventDispatcherImpl, type EventKey, type EventListenMap, EventServiceProvider, EventsNeedBusDispatcherError, EventsNeedClassRegistryError, ExceptionsConfiguration, type ExpandingRule, Expression, Facade, Factory, type FactoryResult, Failed, FailoverTransport, Faker, FakerOverflowError, FileNotFoundError, FileSessionHandler, FileStore, FilesystemManager, FilesystemServiceProvider, ForeignIdColumnDefinition, ForeignKeyDefinition, type ForeignKeyInfo, FormRequest, FormUploadedFile, Gate, type GateAbility, GateResponse, GeneratorCommand, GenericLock, type GlobalScope, Grammar, type GroupAttributes, type GroupHost, GroupRegistrar, type GuardFactory, HandlePrecognitiveRequests, HasApiTokens, HasDatabaseNotifications, type HasDatabaseNotificationsModel, type HasFactory, HasMany, HasManyThrough, HasOne, HasOneOrMany, HasUlids, HasUuids, Hash, HashAlgorithmError, type HashInfo, HashManager, type HasherFactory, type HashingConfig, HashingServiceProvider, type Having, type HealthPage, HelpCommand, type HttpCommandOptions, HttpException, Kernel$1 as HttpKernelImpl, HttpRedirectResponse, HttpRedirector, HttpResponseException, HttpResponseFactory, HttpServerError, HttpServiceProvider, Hub, IncomingRequest, type IncomingRequestOptions, type IndexInfo, type IndexType, Inertia, InertiaError, InertiaHtml, InertiaMiddleware, InertiaPage, Response$1 as InertiaPageResponse, ResponseFactory as InertiaResponseFactory, InertiaServiceProvider, type ValidationErrors as InertiaValidationErrors, InferValidatedType, InvalidCacheConfigError, InvalidCastError, InvalidListenerError, InvalidLogLevelError, InvalidRuleParameterError, InvalidSignatureError, InvalidUrlSignatureError, JOBS_TABLE_MIGRATION, JobClassNotFoundError, type JobContext, type JobMiddleware, JobSerializationError, JoinClause, type JoinType, type JsonWhenCallback, KEY_GENERATE_SIGNATURE, type KernelApp, type KeyGenerateIO, LEVEL_SEVERITY, LazyCollection, type LengthAwarePage, LengthAwarePaginator, ListCommand, type ListenerTuple, type LocalDiskConfig, LocalFilesystem, type LockFactory, LockTimeoutError, Lockout, Log, LogChannelCycleError, LogManager, LogServiceProvider, LogTransport, type LoggedQuery, LogicError, Login, Logout, MIGRATION_CREATE_STUB, MIGRATION_STUB, MIGRATION_UPDATE_STUB, MODEL_EVENTS, Mail, type MailLevel, MailManager, MailMessage, type MailMessageAction, MailNotificationChannel, MailQueueUnavailableError, MailServiceProvider, type MailTransporter, MailUnavailableError, Mailable, MailerImpl, MakeCastCommand, MakeCommandCommand, MakeControllerCommand, MakeEventCommand, MakeFactoryCommand, MakeJobCommand, MakeListenerCommand, MakeMailCommand, MakeMiddlewareCommand, MakeModelCommand, MakeNotificationCommand, MakeObserverCommand, MakePolicyCommand, MakeProviderCommand, MakeRequestCommand, MakeResourceCommand, MakeRuleCommand, MakeSeederCommand, MakeTestCommand, type Manifest, type ManifestChunk, ManuallyFailedError, type Many, MassAssignmentError, MaxAttemptsExceededError, MemoryStore, MergeProp, MessageBagImpl, MethodNotAllowedHttpError, MiddlewareConfiguration, MiddlewareNotFoundError, Migration, MigrationCreator, type MigrationRecord, MigrationRepository, type MigrationStatus, Migrator, type MigratorOptions, MissingAppKeyError, MissingModelError, MissingRecipientError, Model, type ModelBuilder, type ModelClass, type ModelConstructor, type ModelEvent, type ModelListener, ModelNotFoundError, ModelRegistry, type MorphConstraint, MorphMany, MorphOne, MorphTo, MySqlSchemaGrammar, NOTIFICATIONS_TABLE, NOTIFICATIONS_TABLE_MIGRATION, type NewAccessToken, NodeConsoleInput, NodeConsoleOutput, NotDatabaseNotifiableError, NotFoundHttpError, Notifiable, type NotifiableConstructor, Notification, Dispatcher$2 as NotificationDispatcherImpl, NotificationDispatcherUnavailableError, NotificationFacade, NotificationQueueUnavailableError, NotificationsServiceProvider, NullFailedJobProvider, NullLogger, NullQueue, OPERATORS, OnceProp, type OptionDefinition, OptionValue, OptionalProp, type Order, PERSONAL_ACCESS_TOKENS_MIGRATION, type PagePropsFrom, type PaginationLink, Paginator, type PaginatorOptions, type ParsedInput, type ParsedRule, type ParsedSetCookie, type ParsedSignature, Password, PasswordBroker, PasswordBrokerManager, PasswordReset, PasswordRule, PathTraversalError, PendingBatch, PendingChain, PendingDispatch, PersonalAccessToken, PinoLogger, PipelineError, PipelineServiceProvider, Pivot, type PivotIds, type PlainNotificationMail, type PolicyClass, PostgresSchemaGrammar, type PreloadAttributesResolver, PropsResolver, ProviderBootError, ProviderRegisterError, QUEUE_JOB, Builder$1 as QueryBuilder, QueryError, Queue, QueueBase, type QueueCommandContext, QueueError, type QueueJobPayload, Listener as QueueListener, type ListenerConfig as QueueListenerConfig, type ListenerOptions as QueueListenerOptions, type ListenerOutput as QueueListenerOutput, QueueManager, QueueServiceProvider, QueueUnavailableError, Queueable, QueuedConsoleInput, QueuedMailSender, type QueuedMailableFactory, RESTART_CACHE_KEY, RateLimiter, type RawResult, type RecipientOverrides, RedirectIfAuthenticated, RedisJob, RedisLock, RedisQueue, type RedisQueueOptions, RedisRepository, type RedisSessionClient, RedisSessionHandler, RedisStore, RedisTaggedStore, type ReferentialAction, Registered, type RegisteredModel, Relation, type RelationConstraint, type RelationNames, RelationNotFoundError, RelationNotLoadedError, type RelationValue, type RenderCallback, type RenderedContent, type ReplStarter, type ReportCallback, Repository$1 as Repository, ResetPassword, type ResetPasswordMail, type ResolvedMiddleware, type ResolvedServeOptions, type ResourceMethod, type ResourceRoute, type RollbackOptions, Route, RouteArguments, type RouteAttributes, type RouteBinder, RouteDefinition, type RouteFileCallback, type RouteHandler, type RouteListFilters, type RouteListRow, RouteModelNotFoundError, RouteModelResolverImpl, RouteName, RouteNotDefinedError, type RouteStage, RoutesNotifications, RoutingError, type RoutingOptions, RoutingServiceProvider, Rule, type RuleContext, type RunningServer, type Runtime, type S3ClientLike, type S3DiskConfig, S3Filesystem, SCHEDULE_INTERRUPT_KEY, SSR_RENDER_FAILED, STORAGE_LINK_SIGNATURE, Schedule, ScheduleClearCacheCommand, type ScheduleClock, ScheduleImpl, ScheduleInterruptCommand, ScheduleListCommand, ScheduleNameRequiredError, ScheduleRunCommand, ScheduleWorkCommand, type ScheduleWorkOptions, ScheduledEventImpl, Schema, SchemaBuilder, SchemaBuilderToken, SchemaGrammar, type SchemaStep, type Scope, type ScopeCallback, type ScopeStatic, type Scopes, type ScrollMetadata, ScrollProp, Seeder, type SeederClass, type SelectColumn, SendEmailVerificationNotification, SendQueuedMailable, SendQueuedNotifications, type Serialized, type SerializedObject, type ServeOptions, ServiceProvider$1 as ServiceProvider, SessionFacade as Session, type SessionConfig, SessionGuard, type SessionGuardOptions, type SessionHandlerFactory, SessionManager, SessionMessageBag, SessionServiceProvider, Store$1 as SessionStore, type SharedPropsFrom, type SimplePage, type SmtpConfig, SmtpTransport, SoftDeletingScope, type SpawnResult, type SpawnWorker, type Spawner, SqliteSchemaGrammar, SsrError, type SsrFailure, HttpGateway as SsrHttpGateway, type StackFrame, StackLogger, StartSession, type State, type StateContext, Storage, type StoredBatchOptions, type StringPipeResolver, Stringable, type SyncChanges, SyncJob, SyncQueue, type TableRebuild, type TagAttributes, TagsNotSupportedError, TestCommand, ThrottleRequests, ThrottleRequestsError, TimeoutExceededError, TinkerCommand, type TinkerOptions, type TinkerRepl, TokenGuard, type TokenGuardOptions, TokenMismatchError, TokenRepository, type TransporterFactory, TrimStrings, TypeGenerator, type TypeGeneratorOptions, type TypedRedirector, UNIQUE, UNIQUE_LOCK, USERS_TABLE_MIGRATION, UniqueJobsNeedCacheError, UniqueLock, type UniqueLockSpec, type UniqueSpec, UnknownCacheDriverError, UnknownCacheStoreError, UnknownDiskError, UnknownFilesystemDriverError, UnknownLogChannelError, UnknownLogDriverError, UnknownMailTransportError, UnknownMailerError, UnknownNotificationChannelError, UnknownQueueConnectionError, UnknownQueueDriverError, UnknownValidationRuleError, UnrenderableNotificationDataError, UnrenderableNotificationMailError, UnsupportedCipherError, UnsupportedOperationError, type UriParameter, UrlGenerationError, type UrlResolver, type UserProviderFactory, ValidateSignature, Validated, ValidationErrorImpl, ValidationException, ValidationFactoryImpl, ValidationServiceProvider, Validator, ValidatorImpl, type VerifiableUser, Verified, VerifyCsrfToken, VerifyEmail, type VerifyEmailMail, ViewFactoryUnavailableError, Vite, ViteError, ViteHtml, WORKER_DISCOVERY_DIRECTORIES, type Where, type WhereArgs, type WhereBoolean, WithoutOverlapping, Worker, type WorkerListener, type WorkerOptions, abort, abortIf, abortUnless, addApiRouting, allowGuests, applyExceptionCallbacks, applyMiddlewareCallbacks, applyReplacements, auth, back, bcrypt, builtinRules, bunRuntime, cache, castGet, castSet, classNameOf, clientAddress, columnKey, compareRoutes, contentDisposition, cookie, createDailyChannel, createDialect, createPayload, createSingleChannel, createStderrChannel, createToken, csrfToken, currentContainer, currentLogContext, currentRequest, currentVite, databaseConfigDefaults, debugPage, decodePayload, decrypt, defaultAttributeName, defaultListenerOptions, defaultLockFactory, defaultProviders, defaultWorkerOptions, delaySeconds, describeError, deserialize, detectRuntime, discoverClasses, discoverFactories, discoverJobs, discoverListeners, discoverPolicies, dispatch, dispatchRoute, dispatchSync, encodePayload, encrypt, enumValues, env, errorBagFrom, errors, escapeHtml, event, exceedsJsonDepth, expandWildcardKeys, extensionFromMime, fake, filterRouteList, formatAddress, formatDate, formatDateTime, formatRouteList, formatTimestamp, fromEntries, generateAppKey, generateModelTypes, getMorphAlias, getMorphedModel, guessTable, hashInfo, healthResponse, inertia, inertiaBody, inertiaHead, inject, ipMatches, isBlank, isBun, isDateCast, isEmptyValue, isEquivalent, isJsonCast, isListenerClass, isListenerTuple, isModel, isPrecognitive, isQueueable, isQueueableListener, isTableRebuild, isUnique, isUploadedFileLike, joinDiskPath, keyGenerateHandler, listenerOptionsFrom, loadRelations, loadRoutesFrom, logger, makeFailedJobProvider, meetsLevel, mergeGroup, mergeLogContext, mergeRecursive, migrationDatePrefix, minimalPage, modelEventName, morphMap, normalizeAddress, normalizeAddresses, normalizeBackoff, normalizeLists, normalizePath, normalizeUri, old, openSqlite, optionalCookieJar, optionalSession, orderForBindings, parseArgv, parseBracketKey, parseCookieHeader, parseDateTime, parseKey, parseParameters, parseRuleSpec, parseSignature, passwordVerify, prepareValue, queueConfigDefaults, queueOptionsOf, raw as rawSql, rawWithBindings, redirect, registerHttpCommands, registerKeyGenerateCommand, registerMigrationCommands, registerModelTypesCommand, registerQueueCommands, registerStorageLinkCommand, renderContent, renderError, request, requestScope, resolveArguments, resolveDiskPath, resolveMiddleware, resolveMorphClass, resolveOptions, resourceRoutes, response, restoreJob, restoreValue, roundTrip, route, routeListRows, runConsole, runConsoleAndExit, runMiddleware, runSeeder, sanitize, sendEmailVerificationUsing, sendNotification, serialize, serializeContext, serializeCookie, serializeDate, serializeValue, serve, serveBun, serveNode, servePublicFile, session, setClientAddress, stackFrames, statusFor, statusText, storageLinkHandler, substituteBindings, suggest, summarizeValidation, toNotifiableList, toResponse, toWebRequest, tokenableType, transformLeaves, url, usePaginationResolvers, validateRequiredArguments, vite, viteReactRefresh, withHeaders, workerOptionsFrom, writeResponse };