@orieljs/framework 0.1.0-alpha.5 → 0.1.0-alpha.7

package/dist/{testing-BErengYY.d.ts → testing-CKwfWJGn.d.ts}

@@ -1,611 +1,67 @@
-import { Token as Token$2 } from './contracts.js';
-import { S as ServiceProvider$3, A as Application$2 } from './index.d-DOlTeG-8.js';
+import { BusDispatcher, Job, PendingBatchOptions, Class, PendingChain, PendingBatch, Batch, EventDispatcher, Listener, MailManager, Mailable, Address, MailRecipient, Mailer, PendingMail, SentMessage, MailTransport, NotificationDispatcher, Notifiable, Notification, NotificationChannel, QueueManager, QueuePayload, Queue, QueueJob, FilesystemManager, Filesystem, PutOptions, UploadedFile, Application, Session, View, Authenticatable, Container, AuthFactory, InertiaPage, ServiceProvider, ServiceProviderClass, DatabaseManager, ModelInstance, Row, Encrypter, Token, ExceptionHandler, ViewFactory, RouteName, RouteArguments, Rules, InferValidatedType, MessageBag, LiveSnapshot, LiveEffects, OrielError, ErrorKind, Htmlable, LiveManager, HttpRequest, LiveUpdateRequest, LiveUpdateResponse, MiddlewareClass, Router } from './contracts.js';
+import { S as ServiceProvider$1 } from './index.d-WQpfdIbG.js';
 
-/** A typed, runtime-unique key for container bindings. */
-interface Token$1<T> {
-    readonly id: symbol;
-    readonly description: string;
-    /** Phantom field: only carries T at the type level. Never set at runtime. */
-    readonly __type?: T;
-}
-type Class$1<T> = abstract new (...args: any[]) => T;
-type Abstract$1<T> = Token$1<T> | Class$1<T>;
-type Factory$1<T> = (container: Container$1) => T;
-type Concrete$1<T> = Factory$1<T> | (new () => T);
-interface Container$1 {
-    /** New instance on every make(). A class with no concrete binds to itself (constructed with no args). Root only; throws on a scope. */
-    bind<T>(abstract: Abstract$1<T>, concrete?: Concrete$1<T>): void;
-    /** One instance for the life of this container and its scopes. Root only; throws on a scope. */
-    singleton<T>(abstract: Abstract$1<T>, concrete?: Concrete$1<T>): void;
-    /** One instance per scope (e.g. per HTTP request or queue job). Root only; throws on a scope. */
-    scoped<T>(abstract: Abstract$1<T>, concrete?: Concrete$1<T>): void;
-    /** Register an existing object as a shared instance. Returns it. On a scope it stays local to that scope. */
-    instance<T>(abstract: Abstract$1<T>, instance: T): T;
-    /** Resolve. Unbound classes are constructed with `new Class()`. Unbound tokens throw BindingResolutionError. */
-    make<T>(abstract: Abstract$1<T>): T;
-    bound(abstract: Abstract$1<unknown>): boolean;
-    resolved(abstract: Abstract$1<unknown>): boolean;
-    /** Decorate or replace an instance each time it's resolved (applied before resolving callbacks). Root only; throws on a scope. */
-    extend<T>(abstract: Abstract$1<T>, extender: (instance: T, container: Container$1) => T): void;
-    /** Called after each resolution of the abstract. Root only; throws on a scope. */
-    resolving<T>(abstract: Abstract$1<T>, callback: (instance: T, container: Container$1) => void): void;
-    forgetInstance(abstract: Abstract$1<unknown>): void;
-    /** A child container: shares bindings and singletons with its parent, and has its own scoped instances. Bindings can't be registered on it. */
-    createScope(): Container$1;
-    /** Run fn with this container as the "current" one for inject(), helpers and facades (AsyncLocalStorage). */
-    run<R>(fn: () => R): R;
-}
-declare const Container$1: Token$1<Container$1>;
-
-/** The session of the current request (scoped). Loaded and saved by the StartSession middleware. */
-interface Session$1 {
-    getId(): string;
-    start(): Promise<void>;
-    save(): Promise<void>;
-    all(): Record<string, unknown>;
-    has(key: string): boolean;
-    get<T = unknown>(key: string, defaultValue?: T): T;
-    put(key: string | Record<string, unknown>, value?: unknown): void;
-    push(key: string, value: unknown): void;
-    pull<T = unknown>(key: string, defaultValue?: T): T;
-    forget(...keys: string[]): void;
-    flush(): void;
-    flash(key: string, value: unknown): void;
-    now(key: string, value: unknown): void;
-    reflash(): void;
-    keep(...keys: string[]): void;
-    getOldInput<T = unknown>(key?: string, defaultValue?: T): T;
-    flashInput(input: Record<string, unknown>): void;
-    token(): string;
-    regenerateToken(): void;
-    regenerate(destroy?: boolean): Promise<void>;
-    invalidate(): Promise<void>;
-    previousUrl(): string | undefined;
-    setPreviousUrl(url: string): void;
-}
-declare const Session$1: Token$2<Session$1>;
-interface UploadedFile$1 {
-    readonly clientName: string;
-    readonly mimeType: string;
-    readonly size: number;
-    extension(): string;
-    arrayBuffer(): Promise<ArrayBuffer>;
-    /** Stores on a Filesystem disk. Returns the stored path. */
-    store(directory: string, disk?: string): Promise<string>;
-    storeAs(directory: string, name: string, disk?: string): Promise<string>;
-}
-
-interface ServiceProvider$2 {
-    /** Bind things into the container. Synchronous. Don't resolve other services here. */
-    register?(): void;
-    /** Runs after every provider is registered. May be async (e.g. importing route files). */
-    boot?(): void | Promise<void>;
-}
-type ServiceProviderClass$1 = new (app: Application$1) => ServiceProvider$2;
-interface Application$1 extends Container$1 {
-    readonly version: string;
-    basePath(path?: string): string;
-    appPath(path?: string): string;
-    bootstrapPath(path?: string): string;
-    configPath(path?: string): string;
-    databasePath(path?: string): string;
-    publicPath(path?: string): string;
-    resourcePath(path?: string): string;
-    storagePath(path?: string): string;
-    /** With no args returns the environment name. With args returns whether it matches any of them. */
-    environment(): string;
-    environment(...environments: string[]): boolean;
-    isProduction(): boolean;
-    isLocal(): boolean;
-    runningInConsole(): boolean;
-    /** Mark the app as running in the console (the CLI entry point calls this). Defaults to true. */
-    setRunningInConsole(value?: boolean): void;
-    runningUnitTests(): boolean;
-    /** Registers the provider. If the app is already booted, the provider is booted immediately. */
-    register(provider: ServiceProvider$2 | ServiceProviderClass$1): Promise<ServiceProvider$2>;
-    getProviders(): ServiceProvider$2[];
-    boot(): Promise<void>;
-    isBooted(): boolean;
-    booting(callback: (app: Application$1) => void | Promise<void>): void;
-    booted(callback: (app: Application$1) => void | Promise<void>): void;
-    /** Handle one HTTP request in a fresh request scope via the bound HttpKernel. */
-    handle(request: Request): Promise<Response>;
-    /** Register a callback that terminate() runs, in registration order. */
-    terminating(callback: () => void | Promise<void>): void;
-    terminate(): Promise<void>;
-}
-declare const Application$1: Token$2<Application$1>;
-interface ExceptionHandler {
-    report(error: unknown): Promise<void>;
-    shouldReport(error: unknown): boolean;
-    /** `request` is the scoped HttpRequest (Contracts/Http) when available, else the raw Request. */
-    render(request: unknown, error: unknown): Promise<Response>;
-}
-declare const ExceptionHandler: Token$2<ExceptionHandler>;
-
-interface Arrayable<T = unknown> {
-    toArray(): T;
-}
-interface Htmlable$1 {
-    toHtml(): string;
-}
-/** The minimal collection surface contracts rely on (implemented by @orieljs/collections). */
-interface Enumerable<T> extends Iterable<T>, Arrayable<unknown[]> {
-    all(): T[];
-    count(): number;
-    isEmpty(): boolean;
-}
-
-interface Encrypter {
-    /** JSON-serializes unless serialize=false (then value must be a string). AES-256-GCM, keyed by APP_KEY. */
-    encrypt(value: unknown, serialize?: boolean): string;
-    decrypt<T = unknown>(payload: string, unserialize?: boolean): T;
-    encryptString(value: string): string;
-    decryptString(payload: string): string;
-    getKey(): Uint8Array;
-}
-declare const Encrypter: Token$2<Encrypter>;
-
-interface View extends Htmlable$1 {
-    readonly name: string;
-    with(key: string | Record<string, unknown>, value?: unknown): this;
-    render(): Promise<string>;
-}
-/** Resolves 'posts.index' → resources/views/posts/index.tsx and renders it to HTML on the server. */
-interface ViewFactory {
-    make(name: string, data?: Record<string, unknown>): View;
-    exists(name: string): boolean;
-    share(key: string | Record<string, unknown>, value?: unknown): void;
-    composer(views: string | string[], composer: (view: View) => void | Promise<void>): void;
-    /** Renders TSX (an element, a string, an Htmlable, a View, promises of them) to HTML, like Blade::render(). */
-    renderToString(node: unknown): Promise<string>;
-}
-declare const ViewFactory: Token$2<ViewFactory>;
-
-type Operator = '=' | '!=' | '<>' | '<' | '<=' | '>' | '>=' | 'like' | 'not like' | 'ilike' | 'in' | 'not in';
-type Row = Record<string, unknown>;
-/** The minimal query surface other components rely on (Queue, Cache, Session, Validation, Notifications). */
-interface QueryBuilder<T = Row> {
-    select(...columns: string[]): this;
-    where(column: string, value: unknown): this;
-    where(column: string, operator: Operator, value: unknown): this;
-    where(conditions: Row): this;
-    orWhere(column: string, value: unknown): this;
-    orWhere(column: string, operator: Operator, value: unknown): this;
-    whereIn(column: string, values: readonly unknown[]): this;
-    whereNotIn(column: string, values: readonly unknown[]): this;
-    whereNull(column: string): this;
-    whereNotNull(column: string): this;
-    orderBy(column: string, direction?: 'asc' | 'desc'): this;
-    limit(count: number): this;
-    offset(count: number): this;
-    lockForUpdate(): this;
-    get(): Promise<Enumerable<T>>;
-    first(): Promise<T | undefined>;
-    find(id: unknown): Promise<T | undefined>;
-    value<V = unknown>(column: string): Promise<V | undefined>;
-    pluck<V = unknown>(column: string): Promise<Enumerable<V>>;
-    count(): Promise<number>;
-    exists(): Promise<boolean>;
-    insert(values: Row | Row[]): Promise<void>;
-    /**
-     * Inserts rows, skipping any that violate a unique key instead of failing (Laravel's insertOrIgnore). Returns the
-     * number of rows inserted. Nothing is thrown for a duplicate, so a caller's transaction stays usable on Postgres.
-     */
-    insertOrIgnore(values: Row | Row[]): Promise<number>;
-    insertGetId(values: Row, keyName?: string): Promise<number | string>;
-    update(values: Row): Promise<number>;
-    upsert(values: Row | Row[], uniqueBy: string[], update?: string[]): Promise<number>;
-    increment(column: string, amount?: number, extra?: Row): Promise<number>;
-    decrement(column: string, amount?: number, extra?: Row): Promise<number>;
-    delete(): Promise<number>;
-}
-type DriverName = 'pgsql' | 'mysql' | 'sqlite';
-interface DatabaseConnection {
-    getName(): string;
-    getDriverName(): DriverName;
-    table<T = Row>(table: string): QueryBuilder<T>;
-    select<T = Row>(sql: string, bindings?: readonly unknown[]): Promise<T[]>;
-    statement(sql: string, bindings?: readonly unknown[]): Promise<void>;
-    /** Nested calls use savepoints. Rolls back if fn throws. */
-    transaction<R>(fn: (connection: DatabaseConnection) => Promise<R>): Promise<R>;
-    /**
-     * Start a transaction that stays open, for every caller of this connection, until commit()/rollBack().
-     * Nested calls use savepoints. Meant for test isolation (RefreshDatabase); app code uses transaction(fn).
-     */
-    beginTransaction(): Promise<void>;
-    commit(): Promise<void>;
-    /** Rolls back the innermost level opened by beginTransaction(). Does nothing when none is open. */
-    rollBack(): Promise<void>;
-    /** 0 outside a transaction. */
-    transactionLevel(): number;
-}
-interface DatabaseManager extends DatabaseConnection {
-    connection(name?: string): DatabaseConnection;
-    disconnect(name?: string): Promise<void>;
-}
-declare const DatabaseManager: Token$2<DatabaseManager>;
-/** What non-Database components may rely on from a model instance. */
-interface ModelInstance {
-    exists: boolean;
-    getKey(): unknown;
-    getKeyName(): string;
-    getTable(): string;
-    getRouteKey(): unknown;
-    getRouteKeyName(): string;
-    /** The value stored in a polymorphic `*_type` column for this model: its morph map alias, else its class name. */
-    getMorphClass(): string;
-    getAttribute<T = unknown>(key: string): T;
-    setAttribute(key: string, value: unknown): this;
-    fill(attributes: Row): this;
-    save(): Promise<boolean>;
-    delete(): Promise<boolean>;
-    refresh(): Promise<this>;
-    toArray(): Row;
-    toJSON(): Row;
-}
-
-interface Authenticatable {
-    getAuthIdentifierName(): string;
-    getAuthIdentifier(): unknown;
-    getAuthPassword(): string;
-    getRememberToken(): string | undefined;
-    setRememberToken(value: string): void;
-    getRememberTokenName(): string;
-}
-type Credentials = Record<string, unknown>;
-interface UserProvider {
-    retrieveById(id: unknown): Promise<Authenticatable | undefined>;
-    retrieveByToken(id: unknown, token: string): Promise<Authenticatable | undefined>;
-    updateRememberToken(user: Authenticatable, token: string): Promise<void>;
-    retrieveByCredentials(credentials: Credentials): Promise<Authenticatable | undefined>;
-    validateCredentials(user: Authenticatable, credentials: Credentials): Promise<boolean>;
-}
-interface Guard {
-    check(): Promise<boolean>;
-    guest(): Promise<boolean>;
-    user<T extends Authenticatable = Authenticatable>(): Promise<T | undefined>;
-    id(): Promise<unknown>;
-    validate(credentials: Credentials): Promise<boolean>;
-    hasUser(): boolean;
-    setUser(user: Authenticatable): void;
-}
-interface StatefulGuard extends Guard {
-    attempt(credentials: Credentials, remember?: boolean): Promise<boolean>;
-    once(credentials: Credentials): Promise<boolean>;
-    login(user: Authenticatable, remember?: boolean): Promise<void>;
-    loginUsingId(id: unknown, remember?: boolean): Promise<Authenticatable | false>;
-    logout(): Promise<void>;
-}
-interface AuthFactory {
-    guard(name?: string): StatefulGuard | Guard;
-    shouldUse(name: string): void;
-    extend(driver: string, factory: (name: string, config: Record<string, unknown>) => Guard): void;
-    provider(driver: string, factory: (config: Record<string, unknown>) => UserProvider): void;
-}
-declare const AuthFactory: Token$2<AuthFactory>;
-
-/** Options a job class may declare as public fields. Their presence (or implementing ShouldQueue) makes things queueable. */
-interface ShouldQueue {
-    /**
-     * Marks the class as queued at run time: `implements ShouldQueue` leaves no trace once compiled, so the interface
-     * asks for `readonly shouldQueue = true`. Jobs, listeners, mailables and notifications carrying it are queued.
-     */
-    readonly shouldQueue: true;
-    connection?: string;
-    queue?: string;
-    /** Seconds. */
-    delay?: number;
-    tries?: number;
-    /** Seconds, or a per-attempt list. */
-    backoff?: number | number[];
-    /** Seconds. */
-    timeout?: number;
-    uniqueId?(): string;
-}
-/** A job: public fields are its serialized data; handle() runs on the worker (inject() works inside it). */
-interface Job extends Partial<ShouldQueue> {
-    handle(): unknown | Promise<unknown>;
-    failed?(error: unknown): void | Promise<void>;
-}
-interface QueuePayload {
-    uuid: string;
-    /** ClassRegistry name. */
-    job: string;
-    displayName: string;
-    data: Record<string, unknown>;
-    attempts: number;
-    maxTries?: number;
-    backoff?: number[];
-    timeout?: number;
-    /** Unix ms. */
-    pushedAt: number;
-    batchId?: string;
-    chain?: QueuePayload[];
-    /** Unix ms after which the job fails instead of retrying. */
-    retryUntil?: number;
-    /** Mark the job failed (instead of releasing it) when it times out. */
-    failOnTimeout?: boolean;
-}
-interface QueueJob {
-    getJobId(): string;
-    getQueue(): string;
-    payload(): QueuePayload;
-    attempts(): number;
-    delete(): Promise<void>;
-    release(delaySeconds?: number): Promise<void>;
-    /** Marks as failed: stores it via FailedJobProvider and calls job.failed(). */
-    fail(error: unknown): Promise<void>;
-    isDeleted(): boolean;
-    isReleased(): boolean;
-}
-interface Queue {
-    push(job: Job, queue?: string): Promise<string>;
-    later(delaySeconds: number, job: Job, queue?: string): Promise<string>;
-    pushRaw(payload: QueuePayload, queue?: string, delaySeconds?: number): Promise<string>;
-    pop(queue?: string): Promise<QueueJob | undefined>;
-    size(queue?: string): Promise<number>;
-    clear(queue?: string): Promise<number>;
-}
-interface QueueManager extends Queue {
-    connection(name?: string): Queue;
-    extend(driver: string, factory: (config: Record<string, unknown>) => Queue): void;
-}
-declare const QueueManager: Token$2<QueueManager>;
-
-interface Batch {
-    readonly id: string;
-    readonly name: string;
-    readonly totalJobs: number;
-    readonly pendingJobs: number;
-    readonly failedJobs: number;
-    progress(): number;
-    finished(): boolean;
-    cancelled(): boolean;
-    cancel(): Promise<void>;
-}
-interface PendingChain {
-    onConnection(connection: string): this;
-    onQueue(queue: string): this;
-    /** Runs as a job if any job in the chain fails. Callbacks are jobs, because closures can't be serialized. */
-    catch(job: Job): this;
-    dispatch(): Promise<void>;
-}
-interface PendingBatch {
-    name(name: string): this;
-    onConnection(connection: string): this;
-    onQueue(queue: string): this;
-    allowFailures(allow?: boolean): this;
-    then(job: Job): this;
-    catch(job: Job): this;
-    finally(job: Job): this;
-    dispatch(): Promise<Batch>;
-}
-interface BusDispatcher {
-    /** Queues it when the job is queueable (implements ShouldQueue / declares queue options), otherwise runs it now. */
-    dispatch(job: Job): Promise<unknown>;
-    dispatchSync(job: Job): Promise<unknown>;
-    /** Runs after the current response is sent (or the current job finishes). */
-    dispatchAfterResponse(job: Job): void;
-    chain(jobs: Job[]): PendingChain;
-    batch(jobs: Job[]): PendingBatch;
-    findBatch(id: string): Promise<Batch | undefined>;
-}
-declare const BusDispatcher: Token$2<BusDispatcher>;
-/** What PendingBatch hands to the repository. Callbacks are jobs, because closures can't be serialized. */
-interface PendingBatchOptions {
-    name: string;
-    then: Job[];
-    catch: Job[];
-    finally: Job[];
-    allowFailures: boolean;
-    connection?: string;
-    queue?: string;
-}
-
-interface Address {
-    address: string;
-    name?: string;
-}
-/** A plain email string, an Address, or anything with email (+ optional name), such as a User model. */
-type MailRecipient = string | Address | {
-    email: string;
-    name?: string;
-};
-interface Envelope {
-    from?: MailRecipient;
-    to?: MailRecipient[];
-    cc?: MailRecipient[];
-    bcc?: MailRecipient[];
-    replyTo?: MailRecipient[];
-    subject?: string;
-    tags?: string[];
-    metadata?: Record<string, string>;
-}
-interface Content {
-    /** A View name, rendered by ViewFactory (TSX). */
-    view?: string;
-    /** A plain-text view name. */
-    text?: string;
-    /** Raw HTML (used when no view is given). */
-    htmlString?: string;
-    /** Raw plain-text body (used when no text view is given). */
-    textString?: string;
-    with?: Record<string, unknown>;
-}
-interface Attachment {
-    name: string;
-    path?: string;
-    data?: Uint8Array | string;
-    mime?: string;
-}
-/** Laravel 10+ style mailable: envelope() + content() + attachments(). */
-interface Mailable {
-    envelope(): Envelope | Promise<Envelope>;
-    content(): Content | Promise<Content>;
-    attachments?(): Attachment[] | Promise<Attachment[]>;
-}
-/** Fully rendered message handed to a transport. */
-interface OutgoingMessage {
-    from: Address;
-    to: Address[];
-    cc: Address[];
-    bcc: Address[];
-    replyTo: Address[];
-    subject: string;
-    html?: string;
-    text?: string;
-    attachments: Attachment[];
-    headers: Record<string, string>;
-}
-interface SentMessage {
-    messageId: string;
-    message: OutgoingMessage;
-}
-interface MailTransport {
-    send(message: OutgoingMessage): Promise<SentMessage>;
-}
-interface PendingMail {
-    cc(recipients: MailRecipient | MailRecipient[]): this;
-    bcc(recipients: MailRecipient | MailRecipient[]): this;
-    send(mailable: Mailable): Promise<SentMessage | undefined>;
-    queue(mailable: Mailable): Promise<void>;
-    later(delaySeconds: number, mailable: Mailable): Promise<void>;
-}
-interface Mailer {
-    to(recipients: MailRecipient | MailRecipient[]): PendingMail;
-    /** Sends to the recipients given in the mailable's envelope. Queues it if the mailable is queueable. */
-    send(mailable: Mailable): Promise<SentMessage | undefined>;
-    queue(mailable: Mailable): Promise<void>;
-}
-interface MailManager extends Mailer {
-    mailer(name?: string): Mailer;
-    extend(transport: string, factory: (config: Record<string, unknown>) => MailTransport): void;
-}
-declare const MailManager: Token$2<MailManager>;
-
-interface Notifiable {
-    /** e.g. 'mail' → email address, 'database' → the model itself. */
-    routeNotificationFor(channel: string, notification: Notification): unknown;
-}
-interface Notification {
-    /** Optional id; set by the dispatcher when missing. */
-    id?: string;
-    via(notifiable: Notifiable): string[];
-    /** Returns a Mailable (Contracts/Mail) or the Notifications MailMessage builder. */
-    toMail?(notifiable: Notifiable): unknown;
-    toDatabase?(notifiable: Notifiable): Record<string, unknown>;
-    toArray?(notifiable: Notifiable): Record<string, unknown>;
-}
-interface NotificationChannel {
-    send(notifiable: Notifiable, notification: Notification): Promise<void>;
-}
-interface NotificationDispatcher {
-    /** Queues it when the notification is queueable, otherwise sends immediately. */
-    send(notifiables: Notifiable | Notifiable[], notification: Notification): Promise<void>;
-    sendNow(notifiables: Notifiable | Notifiable[], notification: Notification, channels?: string[]): Promise<void>;
-    /** On-demand: Notification.route('mail', 'a@b.c').notify(n). */
-    route(channel: string, route: unknown): Notifiable & {
-        notify(notification: Notification): Promise<void>;
-    };
-    extend(channel: string, factory: () => NotificationChannel): void;
-}
-declare const NotificationDispatcher: Token$2<NotificationDispatcher>;
-
-type ListenerClass<E> = Class$1<{
-    handle(event: E): unknown;
-}>;
-type Listener<E> = ((event: E) => unknown) | ListenerClass<E>;
-interface EventDispatcher {
-    /** Class events (recommended) or string events like 'eloquent.created: Post'. */
-    listen<E>(events: Class$1<E> | string | Array<Class$1<E> | string>, listener: Listener<E>): void;
-    hasListeners(event: Class$1<unknown> | string): boolean;
-    /** Runs listeners in registration order. Listener classes that are queueable are queued. Returns results. */
-    dispatch(event: object | string, payload?: unknown[]): Promise<unknown[]>;
-    /** Stops at the first listener that returns something other than undefined. Returns that value. */
-    until(event: object | string, payload?: unknown[]): Promise<unknown>;
-    subscribe(subscriber: Class$1<{
-        subscribe(events: EventDispatcher): void;
-    }>): void;
-    forget(event: Class$1<unknown> | string): void;
-}
-declare const EventDispatcher: Token$2<EventDispatcher>;
-
-interface PutOptions {
-    visibility?: 'public' | 'private';
-    mimeType?: string;
-}
-/** Paths are relative to the disk root. Throws on paths that escape it ('../'). */
-interface Filesystem {
-    exists(path: string): Promise<boolean>;
-    missing(path: string): Promise<boolean>;
-    get(path: string): Promise<string>;
-    getBytes(path: string): Promise<Uint8Array>;
-    readStream(path: string): Promise<ReadableStream<Uint8Array>>;
-    put(path: string, contents: string | Uint8Array | ReadableStream<Uint8Array>, options?: PutOptions): Promise<boolean>;
-    /** Stores under a generated unique name. Returns the stored path. */
-    putFile(directory: string, file: UploadedFile$1, options?: PutOptions): Promise<string>;
-    putFileAs(directory: string, file: UploadedFile$1, name: string, options?: PutOptions): Promise<string>;
-    delete(paths: string | string[]): Promise<boolean>;
-    copy(from: string, to: string): Promise<boolean>;
-    move(from: string, to: string): Promise<boolean>;
-    size(path: string): Promise<number>;
-    lastModified(path: string): Promise<Date>;
-    mimeType(path: string): Promise<string | undefined>;
-    url(path: string): string;
-    temporaryUrl(path: string, expiresAt: Date): Promise<string>;
-    files(directory?: string, recursive?: boolean): Promise<string[]>;
-    directories(directory?: string, recursive?: boolean): Promise<string[]>;
-    makeDirectory(path: string): Promise<boolean>;
-    deleteDirectory(path: string): Promise<boolean>;
-    /** Absolute local path (local disks only). */
-    path(path: string): string;
-}
-interface FilesystemManager extends Filesystem {
-    disk(name?: string): Filesystem;
-    extend(driver: string, factory: (config: Record<string, unknown>) => Filesystem): void;
-}
-declare const FilesystemManager: Token$2<FilesystemManager>;
-
-/** Infinite-scroll metadata for one prop (page.scrollProps[path]). */
-interface InertiaScrollProp {
-    pageName: string;
-    previousPage: string | number | null;
-    nextPage: string | number | null;
-    currentPage: string | number | null;
-    reset: boolean;
-}
-/** A once prop the client keeps between visits (page.onceProps[key]). `expiresAt` is epoch milliseconds. */
-interface InertiaOnceProp {
-    prop: string;
-    expiresAt: number | null;
-}
+/** A date the tests travel to: a Date, an ISO string or milliseconds since the epoch. */
+type TravelDate = Date | string | number;
+/**
+ * Laravel's travelTo(): the clock stands at `date` (new Date(), Date.now() and now() all read it) until travelBack().
+ * With a callback, it runs there and the clock travels back after it; its result is returned.
+ */
+declare function travelTo(date: TravelDate): void;
+declare function travelTo<R>(date: TravelDate, callback: (date: Date) => R): R;
+/** Laravel's travelBack(): the real clock again. Returns the real time. */
+declare function travelBack(): Date;
+/** Laravel's freezeTime(): holds the clock where it is now. Returns that time, or the callback's result. */
+declare function freezeTime(): Date;
+declare function freezeTime<R>(callback: (date: Date) => R): R;
+/** Laravel's freezeSecond(): freezeTime() at the start of the current second. */
+declare function freezeSecond(): Date;
+declare function freezeSecond<R>(callback: (date: Date) => R): R;
+/** Laravel's travel(5).minutes(): moves the clock on (a negative value moves it back) from where it stands. */
+declare function travel(value: number): Wormhole;
 /**
- * The Inertia page object (protocol v3, @inertiajs/core 3.x). Only component, props, url and version are always
- * present; the other fields are left out when empty or false.
+ * Laravel's Wormhole: each unit moves the clock by `value` of it (months and years overflow as Carbon's do: 31 January
+ * plus a month is 3 March), in UTC. With a callback, it runs there, the clock travels back after it, and its result is
+ * returned. JavaScript dates hold milliseconds, so there are no microseconds.
  */
-interface InertiaPage {
-    component: string;
-    props: Record<string, unknown>;
-    /** Path and query, never absolute: '/posts?page=2'. */
-    url: string;
-    /** '' when the app has no asset version. */
-    version: string;
-    sharedProps?: string[];
-    mergeProps?: string[];
-    prependProps?: string[];
-    deepMergeProps?: string[];
-    /** '<prop path>.<key field>', e.g. 'posts.data.id'. */
-    matchPropsOn?: string[];
-    /** Group name → prop paths loaded after the first render. */
-    deferredProps?: Record<string, string[]>;
-    rescuedProps?: string[];
-    scrollProps?: Record<string, InertiaScrollProp>;
-    onceProps?: Record<string, InertiaOnceProp>;
-    clearHistory?: true;
-    encryptHistory?: true;
-    flash?: Record<string, unknown>;
-    preserveFragment?: true;
+declare class Wormhole {
+    #private;
+    readonly value: number;
+    constructor(value: number);
+    millisecond(): void;
+    millisecond<R>(callback: () => R): R;
+    milliseconds(): void;
+    milliseconds<R>(callback: () => R): R;
+    second(): void;
+    second<R>(callback: () => R): R;
+    seconds(): void;
+    seconds<R>(callback: () => R): R;
+    minute(): void;
+    minute<R>(callback: () => R): R;
+    minutes(): void;
+    minutes<R>(callback: () => R): R;
+    hour(): void;
+    hour<R>(callback: () => R): R;
+    hours(): void;
+    hours<R>(callback: () => R): R;
+    day(): void;
+    day<R>(callback: () => R): R;
+    days(): void;
+    days<R>(callback: () => R): R;
+    week(): void;
+    week<R>(callback: () => R): R;
+    weeks(): void;
+    weeks<R>(callback: () => R): R;
+    month(): void;
+    month<R>(callback: () => R): R;
+    months(): void;
+    months<R>(callback: () => R): R;
+    year(): void;
+    year<R>(callback: () => R): R;
+    years(): void;
+    years<R>(callback: () => R): R;
+    /** Laravel's Wormhole::back(). */
+    static back(): Date;
 }
 
 /**
@@ -623,7 +79,7 @@ declare class PendingCommand implements PromiseLike<number> {
     readonly parameters: Record<string, unknown>;
     private readonly checks;
     private result;
-    constructor(app: Application$1, command: string, parameters?: Record<string, unknown>);
+    constructor(app: Application, command: string, parameters?: Record<string, unknown>);
     /** A line of output equals `line` exactly; with no argument, the command printed something. */
     expectsOutput(line?: string): this;
     /** No line equals `line`; with no argument, the command printed nothing at all. */
@@ -767,9 +223,9 @@ interface ResponseContext {
     /** The raw request sent to the kernel (redirect URLs are resolved against it). */
     request?: Request;
     /** The application that handled it. */
-    app?: Application$1;
+    app?: Application;
     /** The request's session after the response. */
-    session?: Session$1;
+    session?: Session;
     /** Views made while handling the request, in order. */
     views?: View[];
     /** The last error the exception handler rendered. */
@@ -881,7 +337,7 @@ declare class TestResponse {
     /** Validation errors for these keys (message fragments match with "contains"): JSON body or session. */
     assertInvalid(errors: ExpectedErrors, errorBag?: string, responseKey?: string): this;
     /** The request's session after the response (flashed data is still there). */
-    session(): Session$1;
+    session(): Session;
     /** A key (with an optional value or predicate), several keys, or a { key: value } record. */
     assertSessionHas(key: string | string[] | Record<string, unknown>, value?: unknown): this;
     assertSessionHasAll(bindings: Record<string, unknown>): this;
@@ -946,7 +402,7 @@ interface RequestOptions {
  * requests, actingAs users and options, plus the dispatch itself.
  */
 declare class HttpClient {
-    protected readonly app: Application$1;
+    protected readonly app: Application;
     readonly headers: Record<string, string>;
     /** Cookies to encrypt on send (withCookie) and to send as-is (withUnencryptedCookie, or captured from responses). */
     readonly cookies: Map<string, {
@@ -961,14 +417,19 @@ declare class HttpClient {
     defaultGuard: string | undefined;
     /** Session attributes carried from one request to the next (Laravel keeps one session store per test). */
     session: Record<string, unknown> | undefined;
+    /**
+     * withSession() and flushSession() since the last started session: applied to the stored session (the one the
+     * session cookie points to) once the next request starts it, so they win over what it holds, as in Laravel.
+     */
+    sessionChanges: Array<(session: Session) => void>;
     /** from(url): the session's previous URL for the next request only (Laravel sets it once). */
     previousUrl: string | undefined;
     /** Requests whose actingAs users reached the guards (the AuthFactory they went through). */
     private readonly actingAsApplied;
-    constructor(app: Application$1);
+    constructor(app: Application);
     request(method: string, uri: string, options?: RequestOptions): Promise<TestResponse>;
     /** Runs `fn` in a scope prepared like a request's (carried session, actingAs users), e.g. for assertAuthenticated(). */
-    inScope<T>(fn: (scope: Container$1) => T | Promise<T>): Promise<T>;
+    inScope<T>(fn: (scope: Container) => T | Promise<T>): Promise<T>;
     /**
      * Runs `run` in a request scope like this client's requests have (a request for `method uri` bound, the carried
      * session, actingAs users), then carries the session and the users on, as after a request. Live.test() runs its
@@ -978,16 +439,20 @@ declare class HttpClient {
     /** Runs the request through the app's real HttpKernel, in a request scope this client owns. */
     protected send(request: Request): Promise<TestResponse>;
     /** Prepares the request scope: recorders, the carried session and actingAs users. */
-    protected beforeRequest(scope: Container$1, context: ResponseContext): void;
+    protected beforeRequest(scope: Container, context: ResponseContext): void;
     /** Keeps the session for the next request, like Laravel's per-test session store, and the guards' users. */
-    protected afterRequest(_scope: Container$1, context: ResponseContext): Promise<void>;
+    protected afterRequest(_scope: Container, context: ResponseContext): Promise<void>;
     /**
      * Laravel's actingAs() sets the user on the guard once, so a logout (or a login as someone else) in the
      * request sticks. Reads each actingAs guard back and forgets or replaces its user to match.
      */
     protected syncActingAs(auth: AuthFactory): Promise<void>;
+    /** Applies the pending withSession()/flushSession() changes once the session has loaded what it stored. */
+    protected applyOnStart(session: Session): void;
+    /** Applies the pending withSession()/flushSession() changes to the session, once. */
+    protected applyPending(session: Session): void;
     /** The request's (scoped) Session, created now so the carried attributes are in place before StartSession. */
-    protected scopeSession(scope: Container$1): Session$1 | undefined;
+    protected scopeSession(scope: Container): Session | undefined;
     buildRequest(method: string, uri: string, options: RequestOptions): Request;
     protected baseUrl(): string;
     protected cookieHeader(): string;
@@ -1032,20 +497,20 @@ declare abstract class InteractsWithApplication {
         hooks?: TestHooks;
     }, options?: BootOptions): T;
     /** The current test's application. */
-    get app(): Application$1;
+    get app(): Application;
     /**
      * A fresh application for one test. tests/TestCase.ts overrides this to call bootstrap/app's factory.
      * The default builds one at basePath() with providers(), for package tests with no skeleton.
      */
-    createApplication(): Promise<Application$1>;
+    createApplication(): Promise<Application>;
     /** Used by the default createApplication(). */
     protected basePath(): string;
     /** Used by the default createApplication(). */
-    protected providers(): Array<ServiceProvider$2 | ServiceProviderClass$1>;
+    protected providers(): Array<ServiceProvider | ServiceProviderClass>;
     /** The variables applied (unless already set) before each application is created. */
     protected environment(): Record<string, string>;
     /** Adjust the fresh app before it boots, e.g. `app.make(ConfigRepository).set('mail.default', 'array')`. */
-    protected defineEnvironment(_app: Application$1): void | Promise<void>;
+    protected defineEnvironment(_app: Application): void | Promise<void>;
     setUp(): Promise<void>;
     tearDown(): Promise<void>;
     /**
@@ -1082,9 +547,9 @@ declare abstract class MakesHttpRequests extends InteractsWithApplication {
     followingRedirects(): this;
     /** Sets the Referer and the session's previous URL, so redirect()->back() goes there. */
     from(url: string): this;
-    /** Puts data in the session for the following requests (Laravel's withSession()). */
+    /** Puts data in the session for the following requests, over what the stored session holds (Laravel's withSession()). */
     withSession(data: Record<string, unknown>): this;
-    /** Empties the session carried between requests. */
+    /** Empties the session, the stored one included, so the next request starts with none (Laravel's flushSession()). */
     flushSession(): this;
     /** Every following request is authenticated as `user` on `guard` (which also becomes the default guard). */
     actingAs(user: Authenticatable, guard?: string): this;
@@ -1143,11 +608,28 @@ declare abstract class InteractsWithConsole extends InteractsWithDatabase {
     artisan(command: string, parameters?: Record<string, unknown>): PendingCommand;
 }
 
+/**
+ * Laravel's InteractsWithTime: `t.travelTo(date)`, `t.travel(5).minutes()`, `t.freezeTime()`, `t.travelBack()`.
+ * The functions of the same names do the same outside a test case. A test case's tearDown travels back, so each of its
+ * tests ends in the real time; with the plain functions, call `travelBack()` in your own `afterEach()` or pass a callback.
+ */
+declare abstract class InteractsWithTime extends InteractsWithConsole {
+    travelTo(date: TravelDate): void;
+    travelTo<R>(date: TravelDate, callback: (date: Date) => R): R;
+    travel(value: number): Wormhole;
+    travelBack(): Date;
+    freezeTime(): Date;
+    freezeTime<R>(callback: (date: Date) => R): R;
+    freezeSecond(): Date;
+    freezeSecond<R>(callback: (date: Date) => R): R;
+    tearDown(): Promise<void>;
+}
+
 /**
  * Laravel's TestCase. Extend it in tests/TestCase.ts (override createApplication() and set `static hooks`),
  * then in each file: `const t = TestCase.boot()`, or `TestCase.boot({ uses: [RefreshDatabase] })`.
  */
-declare abstract class TestCase extends InteractsWithConsole {
+declare abstract class TestCase extends InteractsWithTime {
 }
 
 /**
@@ -1188,9 +670,9 @@ declare const RefreshDatabaseState: {
     migrated: boolean;
 };
 /** Runs a console command through the ConsoleKernel contract; a non-zero exit fails the test with its output. */
-declare function runCommand(app: Application$1, command: string, parameters?: Record<string, unknown>): Promise<void>;
+declare function runCommand(app: Application, command: string, parameters?: Record<string, unknown>): Promise<void>;
 /** Laravel's usingInMemoryDatabase(): the default connection's database is ':memory:'. */
-declare function usingInMemoryDatabase(app: Application$1): boolean;
+declare function usingInMemoryDatabase(app: Application): boolean;
 /**
  * Laravel's RefreshDatabase.
  * - In-memory SQLite: every test's new application has an empty database, so it just runs `migrate`.
@@ -1204,11 +686,11 @@ declare const DatabaseMigrations: TestTrait;
 declare const DatabaseTransactions: TestTrait;
 
 /** What an assertion targets: a class (exact constructor), or a name (a string event, a class name or a registry name). */
-type Target<T = unknown> = Class$1<T> | string;
+type Target<T = unknown> = Class<T> | string;
 /** A count, or a filter over the recorded items. */
 type CountOrFilter<A extends unknown[]> = number | ((...args: A) => boolean);
 /** Swaps the fake in through the facade machinery (`facade(token).swap(fake)`: an instance on the current container). */
-declare function install<T extends object, F extends T>(token: Token$1<T>, fake: F): F;
+declare function install<T extends object, F extends T>(token: Token<T>, fake: F): F;
 declare function nameOf(target: Target | object): string;
 /** A recorded object (or string event) matches a target: same constructor, or the same (class) name. */
 declare function matches(item: unknown, target: Target): boolean;
@@ -1219,6 +701,8 @@ interface DispatchedEvent {
     payload: unknown[];
 }
 type EventFilter<E> = (event: E, payload: unknown[]) => boolean;
+/** A listener as assertListening() expects it: a class, a [class, method] pair, a closure, or Function for any closure. */
+type ExpectedListener = Listener<never> | readonly [Class<object>, string] | FunctionConstructor;
 /**
  * Laravel's Event::fake(): records dispatched events instead of running listeners. With a list, only those
  * events are faked and everything else reaches the original dispatcher (so model events keep working).
@@ -1235,25 +719,31 @@ declare class EventFake implements EventDispatcher {
     static fakeExcept(eventsToDispatch: Target | Target[]): EventFake;
     private static original;
     except(events: Target | Target[]): this;
-    listen<E>(events: Class$1<E> | string | Array<Class$1<E> | string>, listener: Listener<E>): void;
-    hasListeners(event: Class$1<unknown> | string): boolean;
+    listen<E>(events: Class<E> | string | Array<Class<E> | string>, listener: Listener<E>): void;
+    hasListeners(event: Class<unknown> | string): boolean;
     dispatch(event: object | string, payload?: unknown[]): Promise<unknown[]>;
     /** Faked events return undefined (never false), so halting model events such as `saving` still proceed. */
     until(event: object | string, payload?: unknown[]): Promise<unknown>;
-    subscribe(subscriber: Class$1<{
+    subscribe(subscriber: Class<{
         subscribe(events: EventDispatcher): void;
     }>): void;
-    forget(event: Class$1<unknown> | string): void;
+    forget(event: Class<unknown> | string): void;
     /** Dispatched at least once; a number asserts the exact count; a function filters (event, payload). */
-    assertDispatched<E>(event: Class$1<E> | string, callback?: CountOrFilter<[E, unknown[]]>): void;
-    assertDispatchedTimes<E>(event: Class$1<E> | string, times?: number): void;
-    assertNotDispatched<E>(event: Class$1<E> | string, callback?: EventFilter<E>): void;
+    assertDispatched<E>(event: Class<E> | string, callback?: CountOrFilter<[E, unknown[]]>): void;
+    assertDispatchedTimes<E>(event: Class<E> | string, times?: number): void;
+    assertNotDispatched<E>(event: Class<E> | string, callback?: EventFilter<E>): void;
     assertNothingDispatched(): void;
-    /** The original dispatcher has a listener for the event. */
-    assertListening(event: Class$1<unknown> | string): void;
+    /**
+     * Laravel's assertListening(event, listener): the original dispatcher has that listener for the event (a class, a
+     * [class, method] pair, the same closure, or Function for any closure; wildcard listeners count for a string event).
+     * With only the event, any listener will do.
+     */
+    assertListening(event: Class<unknown> | string, listener?: ExpectedListener): void;
     /** The recorded events (objects, or names for string events) that match. */
-    dispatched<E>(event: Class$1<E> | string, callback?: EventFilter<E>): E[];
-    hasDispatched(event: Class$1<unknown> | string): boolean;
+    dispatched<E>(event: Class<E> | string, callback?: EventFilter<E>): E[];
+    hasDispatched(event: Class<unknown> | string): boolean;
+    /** The original dispatcher's listeners for the event, as registered, wildcard ones included for a string event. */
+    private listenersFor;
     private shouldFake;
 }
 
@@ -1407,6 +897,8 @@ declare class MailFake implements MailManager {
     mailer(name?: string): Mailer;
     to(recipients: MailRecipient | MailRecipient[]): PendingMail;
     send(mailable: Mailable): Promise<SentMessage | undefined>;
+    /** Recorded as sent, never queued, like the real sendNow(). */
+    sendNow(mailable: Mailable): Promise<SentMessage | undefined>;
     queue(mailable: Mailable): Promise<void>;
     extend(_transport: string, _factory: (config: Record<string, unknown>) => MailTransport): void;
     /** Sent (not queued) at least once; a number asserts the count; a filter gets (mailable, record). */
@@ -1428,6 +920,7 @@ declare class MailFake implements MailManager {
     hasQueued(mailable: Target<Mailable>): boolean;
     private pending;
     private sendVia;
+    private sendNowVia;
     private queueVia;
     private record;
     private matching;
@@ -1476,7 +969,7 @@ declare class NotificationFake implements NotificationDispatcher {
     /** Sent this many times in total, to anyone. */
     assertSentTimes(notification: Target<Notification>, times: number): void;
     assertCount(expected: number): void;
-    sent<N extends Notification>(notifiable: Notifiable, notification: Target<N> | Class$1<N>, callback?: Filter<N>): N[];
+    sent<N extends Notification>(notifiable: Notifiable, notification: Target<N> | Class<N>, callback?: Filter<N>): N[];
     hasSent(notifiable: Notifiable, notification: Target<Notification>): boolean;
     private record;
 }
@@ -1507,12 +1000,12 @@ declare class FakeDisk implements Filesystem {
     getBytes(path: string): Promise<Uint8Array>;
     readStream(path: string): Promise<ReadableStream<Uint8Array>>;
     put(path: string, contents: string | Uint8Array | ReadableStream<Uint8Array>, options?: PutOptions): Promise<boolean>;
-    putFile(directory: string, file: UploadedFile$1, options?: PutOptions): Promise<string>;
+    putFile(directory: string, file: UploadedFile, options?: PutOptions): Promise<string>;
     /**
      * The upload's own type, as the S3 disk sends it: its extension(), never the MIME type the client sent as such nor
      * the stored name's type.
      */
-    putFileAs(directory: string, file: UploadedFile$1, name: string, options?: PutOptions): Promise<string>;
+    putFileAs(directory: string, file: UploadedFile, name: string, options?: PutOptions): Promise<string>;
     private write;
     delete(paths: string | string[]): Promise<boolean>;
     copy(from: string, to: string): Promise<boolean>;
@@ -1554,8 +1047,8 @@ declare class StorageFake implements FilesystemManager {
     getBytes(path: string): Promise<Uint8Array<ArrayBufferLike>>;
     readStream(path: string): Promise<ReadableStream<Uint8Array<ArrayBufferLike>>>;
     put(path: string, contents: string | Uint8Array | ReadableStream<Uint8Array>, options?: PutOptions): Promise<boolean>;
-    putFile(directory: string, file: UploadedFile$1, options?: PutOptions): Promise<string>;
-    putFileAs(directory: string, file: UploadedFile$1, name: string, options?: PutOptions): Promise<string>;
+    putFile(directory: string, file: UploadedFile, options?: PutOptions): Promise<string>;
+    putFileAs(directory: string, file: UploadedFile, name: string, options?: PutOptions): Promise<string>;
     delete(paths: string | string[]): Promise<boolean>;
     copy(from: string, to: string): Promise<boolean>;
     move(from: string, to: string): Promise<boolean>;
@@ -1587,346 +1080,6 @@ declare const FakeFile: {
     image(name: string, width?: number, height?: number): File;
 };
 
-/** A typed, runtime-unique key for container bindings. */
-interface Token<T> {
-    readonly id: symbol;
-    readonly description: string;
-    /** Phantom field: only carries T at the type level. Never set at runtime. */
-    readonly __type?: T;
-}
-type Class<T> = abstract new (...args: any[]) => T;
-type Abstract<T> = Token<T> | Class<T>;
-type Factory<T> = (container: Container) => T;
-type Concrete<T> = Factory<T> | (new () => T);
-interface Container {
-    /** New instance on every make(). A class with no concrete binds to itself (constructed with no args). Root only; throws on a scope. */
-    bind<T>(abstract: Abstract<T>, concrete?: Concrete<T>): void;
-    /** One instance for the life of this container and its scopes. Root only; throws on a scope. */
-    singleton<T>(abstract: Abstract<T>, concrete?: Concrete<T>): void;
-    /** One instance per scope (e.g. per HTTP request or queue job). Root only; throws on a scope. */
-    scoped<T>(abstract: Abstract<T>, concrete?: Concrete<T>): void;
-    /** Register an existing object as a shared instance. Returns it. On a scope it stays local to that scope. */
-    instance<T>(abstract: Abstract<T>, instance: T): T;
-    /** Resolve. Unbound classes are constructed with `new Class()`. Unbound tokens throw BindingResolutionError. */
-    make<T>(abstract: Abstract<T>): T;
-    bound(abstract: Abstract<unknown>): boolean;
-    resolved(abstract: Abstract<unknown>): boolean;
-    /** Decorate or replace an instance each time it's resolved (applied before resolving callbacks). Root only; throws on a scope. */
-    extend<T>(abstract: Abstract<T>, extender: (instance: T, container: Container) => T): void;
-    /** Called after each resolution of the abstract. Root only; throws on a scope. */
-    resolving<T>(abstract: Abstract<T>, callback: (instance: T, container: Container) => void): void;
-    forgetInstance(abstract: Abstract<unknown>): void;
-    /** A child container: shares bindings and singletons with its parent, and has its own scoped instances. Bindings can't be registered on it. */
-    createScope(): Container;
-    /** Run fn with this container as the "current" one for inject(), helpers and facades (AsyncLocalStorage). */
-    run<R>(fn: () => R): R;
-}
-declare const Container: Token<Container>;
-
-/** The session of the current request (scoped). Loaded and saved by the StartSession middleware. */
-interface Session {
-    getId(): string;
-    start(): Promise<void>;
-    save(): Promise<void>;
-    all(): Record<string, unknown>;
-    has(key: string): boolean;
-    get<T = unknown>(key: string, defaultValue?: T): T;
-    put(key: string | Record<string, unknown>, value?: unknown): void;
-    push(key: string, value: unknown): void;
-    pull<T = unknown>(key: string, defaultValue?: T): T;
-    forget(...keys: string[]): void;
-    flush(): void;
-    flash(key: string, value: unknown): void;
-    now(key: string, value: unknown): void;
-    reflash(): void;
-    keep(...keys: string[]): void;
-    getOldInput<T = unknown>(key?: string, defaultValue?: T): T;
-    flashInput(input: Record<string, unknown>): void;
-    token(): string;
-    regenerateToken(): void;
-    regenerate(destroy?: boolean): Promise<void>;
-    invalidate(): Promise<void>;
-    previousUrl(): string | undefined;
-    setPreviousUrl(url: string): void;
-}
-declare const Session: Token$2<Session>;
-
-/** A rule object (Laravel's ValidationRule). Call fail() to reject the value. */
-interface ValidationRule {
-    validate(attribute: string, value: unknown, fail: (message: string) => void, data: Record<string, unknown>): void | Promise<void>;
-}
-/** 'required|string|max:255', or an array mixing strings and rule objects. Keys support dot + `*` wildcards. */
-type Rules = Record<string, string | ReadonlyArray<string | ValidationRule>>;
-interface MessageBag {
-    has(key: string): boolean;
-    first(key?: string): string | undefined;
-    get(key: string): string[];
-    all(): string[];
-    isEmpty(): boolean;
-    count(): number;
-    toObject(): Record<string, string[]>;
-}
-interface UploadedFile {
-    readonly clientName: string;
-    readonly mimeType: string;
-    readonly size: number;
-    extension(): string;
-    arrayBuffer(): Promise<ArrayBuffer>;
-    /** Stores on a Filesystem disk. Returns the stored path. */
-    store(directory: string, disk?: string): Promise<string>;
-    storeAs(directory: string, name: string, disk?: string): Promise<string>;
-}
-/**
- * Oriel's request wrapper (one per request, scoped).
- * The Http kernel awaits `load()` before any middleware runs, so every input accessor below is synchronous.
- */
-interface HttpRequest {
-    readonly raw: Request;
-    load(): Promise<this>;
-    method(): string;
-    isMethod(method: string): boolean;
-    url(): string;
-    fullUrl(): string;
-    path(): string;
-    is(...patterns: string[]): boolean;
-    routeIs(...names: string[]): boolean;
-    header(name: string): string | undefined;
-    header(name: string, defaultValue: string): string;
-    bearerToken(): string | undefined;
-    ip(): string | undefined;
-    /** The raw body as text (Laravel's getContent()); '' when there is none. */
-    content(): string;
-    expectsJson(): boolean;
-    ajax(): boolean;
-    query<T = unknown>(key?: string, defaultValue?: T): T;
-    input<T = unknown>(key?: string, defaultValue?: T): T;
-    all(): Record<string, unknown>;
-    only(...keys: string[]): Record<string, unknown>;
-    except(...keys: string[]): Record<string, unknown>;
-    has(...keys: string[]): boolean;
-    filled(key: string): boolean;
-    boolean(key: string, defaultValue?: boolean): boolean;
-    integer(key: string, defaultValue?: number): number;
-    merge(values: Record<string, unknown>): this;
-    file(key: string): UploadedFile | undefined;
-    cookie(name: string): string | undefined;
-    /** Replace the parsed request cookies (EncryptCookies calls this after decrypting). */
-    setCookies(cookies: Record<string, string>): void;
-    /** Route parameter (after model binding), or every parameter when called with no key. */
-    route<T = unknown>(key?: string): T;
-    session(): Session;
-    /** The user resolved earlier by auth middleware. Undefined for guests. Use `await Auth.user()` to resolve lazily. */
-    user<T = unknown>(guard?: string): T | undefined;
-    setUserResolver(resolver: (guard?: string) => unknown): void;
-    /** Validates this request's input via the ValidationFactory; throws a Validation OrielError (422) on failure. */
-    validate<T = Record<string, unknown>>(rules: Rules, messages?: Record<string, string>, attributes?: Record<string, string>): Promise<T>;
-}
-declare const HttpRequest: Token$2<HttpRequest>;
-type Next = (request: HttpRequest) => Promise<Response>;
-interface Middleware {
-    handle(request: HttpRequest, next: Next, ...parameters: string[]): Promise<Response>;
-    terminate?(request: HttpRequest, response: Response): Promise<void>;
-}
-type MiddlewareClass = new (...args: any[]) => Middleware;
-
-interface ServiceProvider$1 {
-    /** Bind things into the container. Synchronous. Don't resolve other services here. */
-    register?(): void;
-    /** Runs after every provider is registered. May be async (e.g. importing route files). */
-    boot?(): void | Promise<void>;
-}
-type ServiceProviderClass = new (app: Application) => ServiceProvider$1;
-interface Application extends Container {
-    readonly version: string;
-    basePath(path?: string): string;
-    appPath(path?: string): string;
-    bootstrapPath(path?: string): string;
-    configPath(path?: string): string;
-    databasePath(path?: string): string;
-    publicPath(path?: string): string;
-    resourcePath(path?: string): string;
-    storagePath(path?: string): string;
-    /** With no args returns the environment name. With args returns whether it matches any of them. */
-    environment(): string;
-    environment(...environments: string[]): boolean;
-    isProduction(): boolean;
-    isLocal(): boolean;
-    runningInConsole(): boolean;
-    /** Mark the app as running in the console (the CLI entry point calls this). Defaults to true. */
-    setRunningInConsole(value?: boolean): void;
-    runningUnitTests(): boolean;
-    /** Registers the provider. If the app is already booted, the provider is booted immediately. */
-    register(provider: ServiceProvider$1 | ServiceProviderClass): Promise<ServiceProvider$1>;
-    getProviders(): ServiceProvider$1[];
-    boot(): Promise<void>;
-    isBooted(): boolean;
-    booting(callback: (app: Application) => void | Promise<void>): void;
-    booted(callback: (app: Application) => void | Promise<void>): void;
-    /** Handle one HTTP request in a fresh request scope via the bound HttpKernel. */
-    handle(request: Request): Promise<Response>;
-    /** Register a callback that terminate() runs, in registration order. */
-    terminating(callback: () => void | Promise<void>): void;
-    terminate(): Promise<void>;
-}
-declare const Application: Token$2<Application>;
-interface Htmlable {
-    toHtml(): string;
-}
-
-/** Public method names of a controller (excludes non-function members). */
-type ActionMethods<C> = {
-    [K in keyof C]: C[K] extends (...args: any[]) => unknown ? K : never;
-}[keyof C] & string;
-type ControllerAction<C> = readonly [Class<C>, ActionMethods<C>];
-type RouteClosure = (...args: any[]) => unknown;
-/** A class with __invoke(): Route.get('/counter', Counter) (single-action controllers, full-page Live components). */
-type InvokableClass = Class<{
-    __invoke(...args: any[]): unknown;
-}>;
-type RouteAction = RouteClosure | ControllerAction<any> | InvokableClass;
-type MiddlewareReference = string | MiddlewareClass;
-interface Route {
-    readonly methods: readonly string[];
-    readonly uri: string;
-    getName(): string | undefined;
-    name(name: string): this;
-    middleware(...middleware: Array<MiddlewareReference | readonly MiddlewareReference[]>): this;
-    withoutMiddleware(...middleware: MiddlewareReference[]): this;
-    where(parameter: string, pattern: string): this;
-    where(patterns: Record<string, string>): this;
-}
-interface RouteRegistrar {
-    prefix(prefix: string): RouteRegistrar;
-    name(prefix: string): RouteRegistrar;
-    middleware(...middleware: Array<MiddlewareReference | readonly MiddlewareReference[]>): RouteRegistrar;
-    controller(controller: Class<unknown>): RouteRegistrar;
-    group(routes: () => void | Promise<void>): Promise<void>;
-}
-interface ResourceOptions {
-    only?: string[];
-    except?: string[];
-    parameters?: Record<string, string>;
-    names?: Record<string, string>;
-}
-interface Router {
-    get<C>(uri: string, action: ControllerAction<C> | RouteClosure | InvokableClass | string): Route;
-    post<C>(uri: string, action: ControllerAction<C> | RouteClosure | InvokableClass | string): Route;
-    put<C>(uri: string, action: ControllerAction<C> | RouteClosure | InvokableClass | string): Route;
-    patch<C>(uri: string, action: ControllerAction<C> | RouteClosure | InvokableClass | string): Route;
-    delete<C>(uri: string, action: ControllerAction<C> | RouteClosure | InvokableClass | string): Route;
-    options<C>(uri: string, action: ControllerAction<C> | RouteClosure | InvokableClass | string): Route;
-    any<C>(uri: string, action: ControllerAction<C> | RouteClosure | InvokableClass | string): Route;
-    match<C>(methods: string[], uri: string, action: ControllerAction<C> | RouteClosure | InvokableClass | string): Route;
-    redirect(from: string, to: string, status?: number): Route;
-    view(uri: string, view: string, data?: Record<string, unknown>): Route;
-    /** Route.inertia('/about', 'About', props): a GET route that renders an Inertia page (Laravel's Route::inertia). */
-    inertia(uri: string, component: string, props?: Record<string, unknown>): Route;
-    resource(name: string, controller: Class<unknown>, options?: ResourceOptions): void;
-    apiResource(name: string, controller: Class<unknown>, options?: ResourceOptions): void;
-    fallback(action: RouteAction): Route;
-    prefix(prefix: string): RouteRegistrar;
-    name(prefix: string): RouteRegistrar;
-    middleware(...middleware: Array<MiddlewareReference | readonly MiddlewareReference[]>): RouteRegistrar;
-    controller(controller: Class<unknown>): RouteRegistrar;
-    /** Explicit model binding: Route.model('author', User). */
-    model(parameter: string, model: Class<unknown>): void;
-    /** Custom binding resolver. */
-    bind(parameter: string, resolver: (value: string) => unknown | Promise<unknown>): void;
-    pattern(parameter: string, pattern: string): void;
-    /** Name a middleware class, e.g. aliasMiddleware('auth', Authenticate). */
-    aliasMiddleware(name: string, middleware: MiddlewareClass): this;
-    /** Define (or replace) a middleware group such as 'web' or 'api'. */
-    middlewareGroup(name: string, middleware: MiddlewareReference[]): this;
-    /** Append to a group unless it is already present. */
-    pushMiddlewareToGroup(group: string, middleware: MiddlewareReference): this;
-    getMiddlewareGroups(): Record<string, MiddlewareReference[]>;
-    getRoutes(): readonly Route[];
-    current(): Route | undefined;
-    /** Match the request, bind parameters, run the route middleware and the action. Called by the Http kernel. */
-    dispatch(request: HttpRequest): Promise<Response>;
-}
-declare const Router: Token$2<Router>;
-
-type ErrorKind = 'Http' | 'Server' | 'ModelNotFound' | 'Validation' | 'Authentication' | 'Authorization' | 'TokenMismatch' | 'BindingResolution' | 'CircularDependency' | 'ContainerNotAvailable';
-/** Every error thrown by the framework implements this. The exception handler switches on `kind`. */
-interface OrielError extends Error {
-    readonly kind: ErrorKind;
-    /** HTTP status the error should render as, when relevant. */
-    readonly status?: number;
-    readonly headers?: Record<string, string>;
-}
-
-interface LiveSnapshot {
-    data: Record<string, unknown>;
-    memo: {
-        id: string;
-        /** ClassRegistry name of the component. */
-        name: string;
-        path: string;
-        method: string;
-        children: Record<string, [tag: string, id: string]>;
-        errors: Record<string, string[]>;
-    };
-    /** HMAC-SHA256 of JSON(data + memo), keyed by APP_KEY. */
-    checksum: string;
-}
-interface LiveEffects {
-    html?: string;
-    /** Browser events from this.dispatch(); `self` keeps one on this component, `to` sends it to one component name. */
-    dispatches?: Array<{
-        name: string;
-        params: Record<string, unknown>;
-        self?: true;
-        to?: string;
-    }>;
-    /** Events this component listens to (@On, static listeners); sent with the first render. */
-    listeners?: string[];
-    redirect?: string;
-    /** Follow `redirect` with o:navigate instead of a full page load. */
-    redirectUsingNavigate?: true;
-    returns?: unknown[];
-}
-interface LiveUpdateRequest {
-    components: Array<{
-        /** JSON-encoded LiveSnapshot. */
-        snapshot: string;
-        updates: Record<string, unknown>;
-        calls: Array<{
-            method: string;
-            params: unknown[];
-        }>;
-    }>;
-}
-interface LiveUpdateResponse {
-    components: Array<{
-        snapshot: string;
-        effects: LiveEffects;
-    }>;
-}
-interface LiveManager {
-    register(component: Class<unknown>, name?: string): void;
-    /** Server-renders the first HTML (snapshot embedded). `key` identifies a child inside its parent (o:key). */
-    mount(component: string | Class<unknown>, params?: Record<string, unknown>, key?: string): Promise<string>;
-    /** Checks checksums and CSRF, then applies updates and calls, re-renders and returns new snapshots. */
-    update(request: LiveUpdateRequest): Promise<LiveUpdateResponse>;
-    /**
-     * A full-page component (Route.get('/counter', Counter)): mounts `component` (a component instance) with the current route's parameters and
-     * returns the response, its layout view or a redirect.
-     */
-    page(component: object): Promise<unknown>;
-    isLiveRequest(request: HttpRequest): boolean;
-}
-declare const LiveManager: Token$2<LiveManager>;
-
-declare abstract class ServiceProvider implements ServiceProvider$3 {
-    protected readonly app: Application$2;
-    constructor(app: Application$2);
-    register(): void;
-    boot(): void | Promise<void>;
-    /** Package defaults under `key`; values the app already set win (shallow merge, like Laravel). */
-    protected mergeConfigFrom(defaults: Record<string, unknown>, key: string): void;
-}
-
 /** Marks Live component classes (Symbol.for, so two copies of the package agree). */
 declare const COMPONENT: unique symbol;
 /** A browser event queued by dispatch(). `to` is resolved to a component name when the effects are built. */
@@ -1938,8 +1091,11 @@ interface QueuedDispatch {
 }
 /** The validation errors of a component (Laravel's MessageBag), for render(): `this.errors.first('title')`. */
 declare class ErrorBag implements MessageBag {
+    #private;
     private readonly messages;
     constructor(messages: Record<string, string[]>);
+    /** Adds to the component's errors, as addError() does. */
+    add(key: string, message: string): void;
     has(key: string): boolean;
     first(key?: string): string | undefined;
     get(key: string): string[];
@@ -1970,6 +1126,13 @@ declare abstract class Component {
     static layout?: string;
     /** The page title passed to the layout as `title`. */
     static title?: string;
+    /**
+     * Livewire's #[Lazy]: every embed (and the full page) renders the placeholder first and mounts once the browser shows
+     * it. `<Live component={…} lazy={false} />` mounts one at once. The placeholder is the component's
+     * `placeholder(params)` method (TSX), else the `live.lazy_placeholder` view, else an empty `<div>`: give it the root
+     * element the component renders.
+     */
+    static lazy?: boolean;
     /** Static fallbacks for runtimes without decorators: { event: 'method' }, locked names, computed getter names. */
     static listeners?: Record<string, string>;
     static locked?: string[];
@@ -1983,14 +1146,19 @@ declare abstract class Component {
     redirect(url: string, options?: {
         navigate?: boolean;
     }): void;
-    redirectRoute(name: string, parameters?: unknown, options?: {
+    /**
+     * redirect() to a named route: `this.redirectRoute('posts.show', post, { navigate: true })`. Once `oriel
+     * route:types` has run, the name and the route's parameters are checked, as route()'s are.
+     */
+    redirectRoute<N extends RouteName>(name: N, ...args: RouteArguments<N, [options?: {
         navigate?: boolean;
-    }): void;
+    }]>): void;
     /**
-     * Validates the public state. On success clears the error bag and returns the validated data; on failure fills the
-     * error bag and throws (the rest of the action is skipped and the component re-renders with `errors`).
+     * Validates the public state. On success clears the error bag and returns the validated data, typed from the rules
+     * (`await this.validate({ title: 'required|string' })` is `{ title: string }`); on failure fills the error bag and
+     * throws (the rest of the action is skipped and the component re-renders with `errors`).
      */
-    validate<T = Record<string, unknown>>(rules: Rules, messages?: Record<string, string>, attributes?: Record<string, string>): Promise<T>;
+    validate<const R extends Rules>(rules: R, messages?: Record<string, string>, attributes?: Record<string, string>): Promise<InferValidatedType<R>>;
     addError(key: string, message: string): void;
     /** Clears every error, or only those of `keys`. */
     resetErrorBag(...keys: string[]): void;
@@ -1999,6 +1167,13 @@ declare abstract class Component {
     reset(...properties: string[]): void;
     /** Keeps the current HTML: the response carries the new state but no `html` effect. */
     skipRender(): void;
+    /**
+     * An action for an `o:` directive, typed against its method: `o:click={this.$action(this.delete, tag.id)}` writes
+     * `delete(5)`, and a string where `delete` takes a number is a type error. The arguments are written as JSON, the
+     * trailing `undefined` ones left out so the method's defaults apply. The method must be one of this component's
+     * actions (a public method of its class, not a hook and not @Locked); anything else throws while rendering.
+     */
+    $action<P extends unknown[]>(method: (...params: P) => unknown, ...params: NoInfer<P>): string;
     /** A full-page component as a route action: Route.get('/counter', Counter). Route parameters go to mount(). */
     __invoke(): Promise<unknown>;
 }
@@ -2027,7 +1202,10 @@ declare class Testable<C extends Component = Component> {
     private readonly manager;
     private readonly scope;
     private constructor();
-    /** Mounts `component` with `params`, as `<Live component={…} {...params} />` would. */
+    /**
+     * Mounts `component` with `params`, as `<Live component={…} {...params} />` would. A lazy component mounts at once
+     * (Livewire's withoutLazyLoading()); `{ lazy: true }` renders its placeholder, and `call('__lazyLoad', …)` loads it.
+     */
     static create<C extends Component>(component: Class<C> | string, params?: Record<string, unknown>): Promise<Testable<C>>;
     /** The component instance after the last request. */
     instance(): C;
@@ -2037,7 +1215,14 @@ declare class Testable<C extends Component = Component> {
     html(): string;
     /** The effects of the last request. */
     effects(): LiveEffects;
+    /**
+     * Sets public properties through an update. A file (a FakeFile) or an array of files is uploaded as `o:model` on a
+     * file input does it: the upload rules, the temporary disk, then a TemporaryUploadedFile (or an array) in the
+     * property, or the upload's errors on it (Livewire's).
+     */
     set(path: string | Record<string, unknown>, value?: unknown): Promise<this>;
+    /** Uploads `files` into the property `name` (an array when `multiple`), as the browser's upload calls do. */
+    upload(name: string, files: readonly Blob[], multiple?: boolean): Promise<this>;
     call(method: string, ...params: unknown[]): Promise<this>;
     toggle(path: string): Promise<this>;
     /** Dispatches an event to this component, as the browser does for its listeners. */
@@ -2050,6 +1235,9 @@ declare class Testable<C extends Component = Component> {
     assertDontSee(...values: string[]): this;
     /** Each value appears in the rendered HTML as written (not escaped). */
     assertSeeHtml(...values: string[]): this;
+    /** Each value, HTML-escaped, appears in the rendered text: the HTML with its tags stripped (Livewire's assertSeeText). */
+    assertSeeText(...values: string[]): this;
+    assertDontSeeText(...values: string[]): this;
     assertDispatched(name: string, params?: Record<string, unknown>): this;
     assertNotDispatched(name: string): this;
     /** The error bag has errors for every key given (or any error at all with no keys). */
@@ -2067,6 +1255,11 @@ interface LiveProps {
     component: Class<Component> | string;
     /** Identifies a child inside its parent across re-renders (Livewire's :key / wire:key). */
     'o:key'?: string | number;
+    /**
+     * Renders the placeholder and mounts the component once it scrolls into view (`'on-load'`: once the page starts);
+     * `false` mounts a `static lazy` component at once.
+     */
+    lazy?: boolean | 'on-load';
     [param: string]: unknown;
 }
 /** Blade's @livewire('counter', ['count' => 3], key('c1')): the component's first render, as trusted HTML. */
@@ -2109,10 +1302,25 @@ declare class LiveComponentManager implements LiveManager {
     isLiveRequest(request: HttpRequest): boolean;
     /** The first render: HTML with o:id, o:snapshot and o:effects on the root element. */
     mount(component: string | Class<unknown>, params?: Record<string, unknown>, key?: string): Promise<string>;
-    mountComponent(component: string | Class<unknown>, params?: Record<string, unknown>, existing?: Component): Promise<ComponentResult>;
+    /**
+     * Mounts a component: boot(), the params into its properties, mount(params), then its first render. A lazy one
+     * (`lazy` in the params, or `static lazy`) renders its placeholder instead and mounts when the browser loads it.
+     */
+    mountComponent(component: string | Class<unknown>, embedParams?: Record<string, unknown>, existing?: Component): Promise<ComponentResult>;
+    /**
+     * A lazy component's first render (Livewire's): its placeholder, with the state it has before mount() and the mount
+     * params signed for the `__lazyLoad` call the browser makes when it shows it (`o:lazy`, or `o:lazy-on-load`).
+     */
+    private mountPlaceholder;
     /** Applies each component's updates and calls, re-renders it and returns its new snapshot and effects. */
     update(request: LiveUpdateRequest): Promise<LiveUpdateResponse>;
     updateComponent(snapshotJson: string, updates: Record<string, unknown>, calls: Call[]): Promise<ComponentResult>;
+    /**
+     * The mount params and placeholder tag of a `__lazyLoad` request, or undefined for any other update. The load comes
+     * alone (no updates, no other call: the browser sends it in a request of its own) and its payload must be the one
+     * signed for this component: anything else is refused as corrupt (a 403) before the component boots.
+     */
+    private lazyLoad;
     /**
      * The route action of POST /oriel/live/update. Each component's update runs behind the persistent middleware of the
      * route that rendered its page (Livewire's): `auth`, `verified`, `guest` and `can`, with the page route's parameters
@@ -2131,7 +1339,7 @@ declare class LiveComponentManager implements LiveManager {
     /** Makes every computed getter (static `computed` too) cache its value for the rest of the request. */
     private prepareComputed;
     private applyUpdate;
-    /** Runs one call from the browser: a magic action, an event, or a public method. Returns its return value. */
+    /** Runs one call from the browser: a magic action, an event, an upload call, or a public method. Returns its return value. */
     private call;
     /**
      * Renders the component (rendering/rendered hooks, nested children tracked) and checks for a single root. A
@@ -2151,10 +1359,11 @@ declare class LiveComponentManager implements LiveManager {
 declare const UPDATE_URI = "/oriel/live/update";
 /**
  * Binds the LiveManager and the PaginationState that WithPagination components answer, merges the `live` config,
- * registers POST /oriel/live/update (named `live.update`, in the `web` group: sessions and CSRF apply), the make:live
- * command, and the components under app/Live.
+ * registers POST /oriel/live/update (named `live.update`, in the `web` group: sessions and CSRF apply), the upload and
+ * preview routes of WithFileUploads (`live.upload-file`, `live.preview-file`), the make:live command, and the
+ * components under app/Live.
  */
-declare class LiveServiceProvider extends ServiceProvider {
+declare class LiveServiceProvider extends ServiceProvider$1 {
     register(): void;
     boot(): Promise<void>;
 }
@@ -2202,6 +1411,108 @@ declare class InvalidLiveRequestError extends LiveError {
     readonly kind: ErrorKind;
     readonly status: number;
 }
+/** An upload or preview URL whose signature is missing, wrong or expired (Livewire's 401). Nothing is read or stored. */
+declare class InvalidUploadSignatureError extends LiveError {
+    readonly name: string;
+    readonly kind: ErrorKind;
+    readonly status: number;
+    constructor();
+}
+/** A preview of a temporary upload that is no longer on the disk (cleaned up, or stored and deleted). */
+declare class TemporaryFileNotFoundError extends LiveError {
+    readonly name: string;
+    readonly kind: ErrorKind;
+    readonly status: number;
+    constructor(filename: string);
+}
+/** temporaryUrl() on an upload whose type has no preview (live.temporary_file_upload.preview_mimes). */
+declare class FileNotPreviewableError extends LiveError {
+    readonly name: string;
+    constructor(extension: string);
+}
+/** The errors an upload came back with (`_uploadErrored`): the component re-renders with them on the property. */
+declare class UploadValidationError extends LiveError {
+    readonly errors: Record<string, string[]>;
+    readonly name: string;
+    readonly kind: ErrorKind;
+    readonly status: number;
+    readonly errorBag: string;
+    constructor(errors: Record<string, string[]>);
+}
+
+/**
+ * Livewire's `temporary_file_upload` settings, read from config `live.temporary_file_upload.*` (each one falls back on
+ * its own): the disk (the default filesystem disk), the directory on it, the rules every upload must pass, the upload
+ * route's middleware, the types a preview is served for, how long an upload URL lasts (minutes), and whether a finished
+ * upload removes the temporary files older than a day.
+ */
+declare const TEMPORARY_UPLOAD_DEFAULTS: {
+    disk: string | null;
+    directory: string;
+    rules: string | string[];
+    middleware: string | string[];
+    preview_mimes: string[];
+    max_upload_time: number;
+    cleanup: boolean;
+};
+/** What a temporary upload is: its stored name on the temporary disk and what the browser sent (signed with it). */
+interface TemporaryFileData {
+    /** A random 40-character name with the extension its bytes showed: `live-tmp/<filename>` on the temporary disk. */
+    filename: string;
+    /** The name the browser gave the file. */
+    name: string;
+    size: number;
+    /** The MIME type the browser claimed. */
+    type: string;
+    /** The extension of the upload's own type (its bytes, else a plain claimed extension), or ''. */
+    extension: string;
+}
+/**
+ * Livewire's TemporaryUploadedFile: a file the browser uploaded to the temporary directory before an action stores
+ * it. A WithFileUploads component's property holds one (or an array of them) once `o:model` on a file input has
+ * uploaded it: validate it like any upload (`'photo' => 'image|max:1024'`), preview it with `temporaryUrl()`, then
+ * `store()` it. It travels in the component's snapshot as its data, signed with the rest.
+ */
+declare class TemporaryUploadedFile implements UploadedFile {
+    #private;
+    readonly filename: string;
+    readonly clientName: string;
+    readonly mimeType: string;
+    readonly size: number;
+    constructor(data: TemporaryFileData);
+    /** What the snapshot carries. */
+    toData(): TemporaryFileData;
+    /** The file's path on the temporary disk. */
+    get path(): string;
+    /** The extension of the upload's own type, as FormUploadedFile's extension(): what putFile() names a stored copy by. */
+    extension(): string;
+    /** The extension of the name the browser gave the file, lower-cased ('' without one). */
+    clientExtension(): string;
+    /** A random 40-character name with extension(), as FormUploadedFile's. */
+    hashName(): string;
+    arrayBuffer(): Promise<ArrayBuffer>;
+    text(): Promise<string>;
+    /** The file's bytes from the temporary disk, opened on the first read. */
+    stream(): ReadableStream<Uint8Array>;
+    /** Stores a copy under a random name in `directory`, on `disk` (by default the temporary disk, as Livewire's). */
+    store(directory: string, disk?: string): Promise<string>;
+    storeAs(directory: string, name: string, disk?: string): Promise<string>;
+    exists(): Promise<boolean>;
+    /** Removes the temporary file (a stored copy stays). */
+    delete(): Promise<boolean>;
+    /** Whether temporaryUrl() serves this file: its type is in `live.temporary_file_upload.preview_mimes`. */
+    isPreviewable(): boolean;
+    /**
+     * A signed link to the file for `<img src>` or `<video src>` before it is stored. It lasts until the end of the hour
+     * at least 30 minutes away (Livewire's), so a re-render keeps the same link and the browser doesn't reload it.
+     */
+    temporaryUrl(): string;
+}
+
+/** Where the browser POSTs a WithFileUploads component's files (Livewire's /livewire/upload-file), named live.upload-file. */
+declare const UPLOAD_URI = "/oriel/live/upload-file";
+/** Where temporaryUrl() links lead (Livewire's /livewire/preview-file/{filename}), named live.preview-file. */
+declare const PREVIEW_URI = "/oriel/live/preview-file";
 
 /** The route middleware an update re-applies by default (config live.persistent_middleware), by alias. */
 declare const PERSISTENT_MIDDLEWARE: string[];
@@ -2237,6 +1548,14 @@ interface Paginated {
  */
 declare function WithPagination<TBase extends ComponentConstructor>(Base: TBase): TBase & (abstract new (...args: any[]) => Paginated);
 
+/**
+ * Livewire's WithFileUploads: `class Profile extends WithFileUploads(Component)`. A file input with `o:model="photo"`
+ * uploads the file to the temporary directory as soon as it is picked, then sets `photo` to a TemporaryUploadedFile
+ * (`<input type="file" multiple>` sets an array), through `updatingPhoto()`/`updatedPhoto()` like any update. Validate
+ * it with the file rules, preview it with `temporaryUrl()`, store it with `store()`.
+ */
+declare function WithFileUploads<TBase extends ComponentConstructor>(Base: TBase): TBase;
+
 /**
  * What <Pagination> reads from a paginator. Structural, since Live can't import Database: paginate()'s
  * LengthAwarePaginator (with lastPage(), so page buttons) and simplePaginate()'s Paginator (Previous and Next only).
@@ -2264,4 +1583,4 @@ interface PaginationProps {
  */
 declare function Pagination({ paginator, class: className }: PaginationProps): Htmlable;
 
-export { type JsonStructure as $, AnonymousNotifiable as A, BusFake as B, Component as C, type BootOptions as D, EventFake as E, FakeDisk as F, type CountOrFilter as G, DatabaseMigrations as H, InvalidLiveRequestError as I, type DatabaseTestOptions as J, DatabaseTransactions as K, Live as L, MailFake as M, NotificationFake as N, On as O, PERSISTENT_MIDDLEWARE as P, QueueFake as Q, type DispatchedEvent as R, type ExpectedErrors as S, type Target as T, UPDATE_URI as U, FakeFile as V, WithPagination as W, HttpClient as X, InteractsWithApplication as Y, InteractsWithConsole as Z, InteractsWithDatabase as _, type ComponentResult as a, MailRecord as a0, MakesHttpRequests as a1, PendingCommand as a2, type PushedJob as a3, RefreshDatabase as a4, RefreshDatabaseState as a5, type RequestData as a6, type RequestOptions as a7, type ResponseContext as a8, type ResponseCookie as a9, usingInMemoryDatabase as aA, type SentNotification as aa, StorageFake as ab, TESTING_ENVIRONMENT as ac, type TableOrModel as ad, TestCase as ae, type TestHooks as af, TestResponse as ag, type TestTrait as ah, actingAsAuthFactory as ai, addresses as aj, applyEnvironment as ak, cookieHeader as al, cookiePrefix as am, decryptCookie as an, encryptCookie as ao, flatten as ap, guessMimeType as aq, inertiaPageOf as ar, install as as, isExpired as at, matches as au, nameOf as av, recordingExceptionHandler as aw, recordingViewFactory as ax, responseCookies as ay, runCommand as az, Computed as b, CorruptComponentPayloadError as c, ErrorBag as d, LiveComponentManager as e, LiveComponentNotFoundError as f, LiveError as g, type LiveProps as h, LiveServiceProvider as i, Locked as j, MethodNotCallableError as k, type Paginated as l, Pagination as m, type PaginationProps as n, type PaginationSource as o, PendingEvent as p, type PersistentMiddleware as q, PropertyNotUpdatableError as r, TestRequestScope as s, Testable as t, componentName as u, live as v, persistentMiddleware as w, AssertableInertia as x, AssertableJson as y, type BatchRecord as z };
+export { type DatabaseTestOptions as $, UploadValidationError as A, BusFake as B, Component as C, WithPagination as D, EventFake as E, FileNotPreviewableError as F, componentName as G, live as H, InvalidLiveRequestError as I, persistentMiddleware as J, AnonymousNotifiable as K, Live as L, MailFake as M, NotificationFake as N, On as O, PERSISTENT_MIDDLEWARE as P, QueueFake as Q, AssertableInertia as R, StorageFake as S, TEMPORARY_UPLOAD_DEFAULTS as T, UPDATE_URI as U, AssertableJson as V, WithFileUploads as W, type BatchRecord as X, type BootOptions as Y, type CountOrFilter as Z, DatabaseMigrations as _, type ComponentResult as a, DatabaseTransactions as a0, type DispatchedEvent as a1, type ExpectedErrors as a2, type ExpectedListener as a3, FakeDisk as a4, FakeFile as a5, HttpClient as a6, InteractsWithApplication as a7, InteractsWithConsole as a8, InteractsWithDatabase as a9, cookiePrefix as aA, decryptCookie as aB, encryptCookie as aC, flatten as aD, freezeSecond as aE, freezeTime as aF, guessMimeType as aG, inertiaPageOf as aH, install as aI, isExpired as aJ, matches as aK, nameOf as aL, recordingExceptionHandler as aM, recordingViewFactory as aN, responseCookies as aO, runCommand as aP, travel as aQ, travelBack as aR, travelTo as aS, usingInMemoryDatabase as aT, InteractsWithTime as aa, type JsonStructure as ab, MailRecord as ac, MakesHttpRequests as ad, PendingCommand as ae, type PushedJob as af, RefreshDatabase as ag, RefreshDatabaseState as ah, type RequestData as ai, type RequestOptions as aj, type ResponseContext as ak, type ResponseCookie as al, type SentNotification as am, TESTING_ENVIRONMENT as an, type TableOrModel as ao, type Target as ap, TestCase as aq, type TestHooks as ar, TestResponse as as, type TestTrait as at, type TravelDate as au, Wormhole as av, actingAsAuthFactory as aw, addresses as ax, applyEnvironment as ay, cookieHeader as az, Computed as b, CorruptComponentPayloadError as c, ErrorBag as d, InvalidUploadSignatureError as e, LiveComponentManager as f, LiveComponentNotFoundError as g, LiveError as h, type LiveProps as i, LiveServiceProvider as j, Locked as k, MethodNotCallableError as l, PREVIEW_URI as m, type Paginated as n, Pagination as o, type PaginationProps as p, type PaginationSource as q, PendingEvent as r, type PersistentMiddleware as s, PropertyNotUpdatableError as t, type TemporaryFileData as u, TemporaryFileNotFoundError as v, TemporaryUploadedFile as w, TestRequestScope as x, Testable as y, UPLOAD_URI as z };