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

package/dist/{testing-D3dCOkTm.d.ts → testing-BM481Hdz.d.ts}

@@ -1,604 +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, Rules, MessageBag, LiveSnapshot, LiveEffects, OrielError, ErrorKind, Htmlable, LiveManager, HttpRequest, LiveUpdateRequest, LiveUpdateResponse, MiddlewareClass, Router } from './contracts.js';
+import { S as ServiceProvider$1 } from './index.d-BJyJx6U1.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;
-    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 {
-    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;
 /**
- * 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 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.
  */
-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 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;
+/**
+ * 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.
+ */
+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;
 }
 
 /**
@@ -616,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. */
@@ -760,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. */
@@ -874,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;
@@ -939,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, {
@@ -958,10 +421,10 @@ declare class HttpClient {
     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
@@ -971,16 +434,16 @@ 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>;
     /** 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;
@@ -1025,20 +488,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>;
     /**
@@ -1136,11 +599,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 {
 }
 
 /**
@@ -1181,9 +661,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`.
@@ -1197,11 +677,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;
@@ -1212,6 +692,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).
@@ -1228,25 +710,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;
 }
 
@@ -1400,6 +888,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). */
@@ -1421,6 +911,7 @@ declare class MailFake implements MailManager {
     hasQueued(mailable: Target<Mailable>): boolean;
     private pending;
     private sendVia;
+    private sendNowVia;
     private queueVia;
     private record;
     private matching;
@@ -1469,7 +960,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;
 }
@@ -1480,6 +971,7 @@ interface StoredFile {
     mimeType: string | undefined;
     modified: Date;
 }
+/** By the extension as PHP's pathinfo() reads it: after the last dot of the base name ('.pdf' is a PDF, 'pdf' isn't). */
 declare function guessMimeType(path: string): string | undefined;
 /**
  * An in-memory disk implementing the Filesystem contract, with Laravel's fake-disk assertions. (Laravel's fake
@@ -1499,8 +991,13 @@ 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>;
-    putFileAs(directory: string, file: UploadedFile$1, name: string, 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, name: string, options?: PutOptions): Promise<string>;
+    private write;
     delete(paths: string | string[]): Promise<boolean>;
     copy(from: string, to: string): Promise<boolean>;
     move(from: string, to: string): Promise<boolean>;
@@ -1541,8 +1038,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>;
@@ -1560,351 +1057,19 @@ declare class StorageFake implements FilesystemManager {
 
 /** Laravel's UploadedFile::fake(): File objects to post as multipart uploads (t.post(uri, { avatar: file })). */
 declare const FakeFile: {
-    /** A file of `kilobytes` KiB (zero bytes), typed by `mimeType` or the extension. */
+    /**
+     * A file of `kilobytes` KiB typed by `mimeType` or the name's extension. Validation reads a file's bytes, so the
+     * file starts like its type (a PDF's `%PDF-`, a PNG's signature, text for text types) and passes `mimes` for its
+     * name, as Laravel's fakes do. It is at least its type's leading bytes and never empty, whatever the size asked for.
+     * An image made this way has no readable size: use image() for `dimensions`.
+     */
     create(name: string, kilobytes?: number, mimeType?: string): File;
-    /** A real PNG image of the given size (typed by the name's extension, like Laravel's image()). */
-    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.
+     * A real white image of the given size in the format the name's extension asks for: png, jpg/jpeg, gif, webp or
+     * bmp (any other name gets a JPEG, as Laravel's fakes do), so image, mimes and dimensions pass on it.
      */
-    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;
-}
+    image(name: string, width?: number, height?: number): File;
+};
 
 /** Marks Live component classes (Symbol.for, so two copies of the package agree). */
 declare const COMPONENT: unique symbol;
@@ -1978,6 +1143,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>;
 }
@@ -2029,6 +1201,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). */
@@ -2093,9 +1268,11 @@ declare class LiveComponentManager implements LiveManager {
     update(request: LiveUpdateRequest): Promise<LiveUpdateResponse>;
     updateComponent(snapshotJson: string, updates: Record<string, unknown>, calls: Call[]): Promise<ComponentResult>;
     /**
-     * The route action of POST /oriel/live/update. Each component's update runs behind the auth middleware of the route
-     * that rendered its page (Livewire's persistent middleware): a signed-out tab gets a 401, never the action. When a
-     * middleware answers instead (a redirect), that is the response.
+     * 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
+     * bound again. A signed-out tab gets a 401, a revoked ability a 403 and a deleted model a 404, before the component
+     * hydrates. When a middleware answers instead (a redirect), that is the response. A key first flashed during the
+     * update shows in this response only, unless the update redirects.
      */
     handle(request: HttpRequest): Promise<LiveUpdateResponse | Response>;
     /** A full-page component (Route.get('/counter', Counter)): mounted with the route parameters, inside the layout. */
@@ -2110,8 +1287,14 @@ declare class LiveComponentManager implements LiveManager {
     private applyUpdate;
     /** Runs one call from the browser: a magic action, an event, 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. */
+    /**
+     * Renders the component (rendering/rendered hooks, nested children tracked) and checks for a single root. A
+     * WithPagination component's page and page URL are what paginate() reads while it renders, as in its mount() and in
+     * its update's hooks and actions.
+     */
     private render;
+    /** The absolute URL of the page a memo path belongs to, on the current request's origin ('/' + path without one). */
+    private pageUrl;
     /** Dispatches, redirects: the effects every response carries. */
     private effects;
     /** dehydrate() hook, then the state as snapshot data, the error bag, and the checksum over both. */
@@ -2121,10 +1304,11 @@ declare class LiveComponentManager implements LiveManager {
 /** The URI the client runtime posts updates to. */
 declare const UPDATE_URI = "/oriel/live/update";
 /**
- * Binds the LiveManager, 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.
+ * 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.
  */
-declare class LiveServiceProvider extends ServiceProvider {
+declare class LiveServiceProvider extends ServiceProvider$1 {
     register(): void;
     boot(): Promise<void>;
 }
@@ -2181,10 +1365,57 @@ interface PersistentMiddleware {
     readonly parameters: readonly string[];
 }
 /**
- * Livewire's persistent middleware: the route that rendered the page (the component's memo path and method) is
- * matched again, and the middleware among `persistent` (aliases) that it ran are returned, to run before an update.
- * A path no route matches has none.
+ * Livewire's persistent middleware: the middleware among `persistent` (aliases) that the page route (the component's
+ * memo path and method) ran, in the order an update runs them. A path no route matches has none.
  */
 declare function persistentMiddleware(router: Router, persistent: readonly string[], method: string, path: string): PersistentMiddleware[];
 
-export { RefreshDatabase as $, AnonymousNotifiable as A, BusFake as B, Component as C, DatabaseMigrations as D, EventFake as E, FakeDisk as F, type DispatchedEvent as G, type ExpectedErrors as H, InvalidLiveRequestError as I, FakeFile as J, HttpClient as K, Live as L, MailFake as M, NotificationFake as N, On as O, PERSISTENT_MIDDLEWARE as P, QueueFake as Q, InteractsWithApplication as R, InteractsWithConsole as S, type Target as T, UPDATE_URI as U, InteractsWithDatabase as V, type JsonStructure as W, MailRecord as X, MakesHttpRequests as Y, PendingCommand as Z, type PushedJob as _, type ComponentResult as a, RefreshDatabaseState as a0, type RequestData as a1, type RequestOptions as a2, type ResponseContext as a3, type ResponseCookie as a4, type SentNotification as a5, StorageFake as a6, TESTING_ENVIRONMENT as a7, type TableOrModel as a8, TestCase as a9, type TestHooks as aa, TestResponse as ab, type TestTrait as ac, actingAsAuthFactory as ad, addresses as ae, applyEnvironment as af, cookieHeader as ag, cookiePrefix as ah, decryptCookie as ai, encryptCookie as aj, flatten as ak, guessMimeType as al, inertiaPageOf as am, install as an, isExpired as ao, matches as ap, nameOf as aq, recordingExceptionHandler as ar, recordingViewFactory as as, responseCookies as at, runCommand as au, usingInMemoryDatabase as av, 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, PendingEvent as l, type PersistentMiddleware as m, PropertyNotUpdatableError as n, TestRequestScope as o, Testable as p, componentName as q, live as r, persistentMiddleware as s, AssertableInertia as t, AssertableJson as u, type BatchRecord as v, type BootOptions as w, type CountOrFilter as x, type DatabaseTestOptions as y, DatabaseTransactions as z };
+type ComponentConstructor = abstract new (...args: any[]) => Component;
+/** What WithPagination() adds to a component: its page and the actions that move it. */
+interface Paginated {
+    /** The current page. The browser may set it; Live reads it as a page number. */
+    page: number;
+    nextPage(): Promise<void>;
+    previousPage(): Promise<void>;
+    gotoPage(page: number | string): Promise<void>;
+    resetPage(): Promise<void>;
+    setPage(page: number | string): Promise<void>;
+}
+/**
+ * Livewire's WithPagination: `class Posts extends WithPagination(Component)`. The public `page` (1 to start; there
+ * is no address-bar sync) is what `paginate()` shows in the component (in `render()`, `mount()`, `hydrate()`, the
+ * update hooks and actions, or in a `@Computed` getter any of them reads), and its page links are built on the
+ * page's URL. The actions move it: `o:click="nextPage"`, `previousPage`, `gotoPage(3)`, `setPage(3)`,
+ * `resetPage` (call it from `updatedSearch()` so a new search starts on page 1). `updatingPage(page)` and
+ * `updatedPage(page)` run around every change. One paginator per component: other page names read the request.
+ */
+declare function WithPagination<TBase extends ComponentConstructor>(Base: TBase): TBase & (abstract new (...args: any[]) => Paginated);
+
+/**
+ * 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).
+ */
+interface PaginationSource {
+    currentPage(): number;
+    lastPage?(): number;
+    hasMorePages(): boolean;
+    onFirstPage(): boolean;
+    /** Page buttons on each side of the current one (the paginator's onEachSide(), 3 by default). */
+    readonly onEachSideCount?: number;
+    /** Not cursorPaginate(): its pages are cursors, which a component's page number can't follow. */
+    readonly nextCursor?: never;
+}
+interface PaginationProps {
+    paginator: PaginationSource;
+    /** Classes for the <nav>, such as its layout ("flex gap-2"); in your file, so Tailwind generates them. */
+    class?: string;
+}
+/**
+ * Livewire's pagination links for a WithPagination component: `<Pagination paginator={posts} />` in render(). A
+ * <nav aria-label="Pagination"> with « Previous, the page buttons and Next » as Live actions (previousPage,
+ * gotoPage(n), nextPage), the current page marked aria-current="page", the ends disabled, the kits' theme classes
+ * (btn, btn-secondary). Nothing when everything fits on one page. The address bar is left alone.
+ */
+declare function Pagination({ paginator, class: className }: PaginationProps): Htmlable;
+
+export { InteractsWithDatabase as $, AnonymousNotifiable as A, BusFake as B, Component as C, type CountOrFilter as D, EventFake as E, DatabaseMigrations as F, type DatabaseTestOptions as G, DatabaseTransactions as H, InvalidLiveRequestError as I, type DispatchedEvent as J, type ExpectedErrors as K, Live as L, MailFake as M, NotificationFake as N, On as O, PERSISTENT_MIDDLEWARE as P, QueueFake as Q, type ExpectedListener as R, StorageFake as S, TestRequestScope as T, UPDATE_URI as U, FakeDisk as V, WithPagination as W, FakeFile as X, HttpClient as Y, InteractsWithApplication as Z, InteractsWithConsole as _, type ComponentResult as a, InteractsWithTime as a0, type JsonStructure as a1, MailRecord as a2, MakesHttpRequests as a3, PendingCommand as a4, type PushedJob as a5, RefreshDatabase as a6, RefreshDatabaseState as a7, type RequestData as a8, type RequestOptions as a9, matches as aA, nameOf as aB, recordingExceptionHandler as aC, recordingViewFactory as aD, responseCookies as aE, runCommand as aF, travel as aG, travelBack as aH, travelTo as aI, usingInMemoryDatabase as aJ, type ResponseContext as aa, type ResponseCookie as ab, type SentNotification as ac, TESTING_ENVIRONMENT as ad, type TableOrModel as ae, type Target as af, TestCase as ag, type TestHooks as ah, TestResponse as ai, type TestTrait as aj, type TravelDate as ak, Wormhole as al, actingAsAuthFactory as am, addresses as an, applyEnvironment as ao, cookieHeader as ap, cookiePrefix as aq, decryptCookie as ar, encryptCookie as as, flatten as at, freezeSecond as au, freezeTime as av, guessMimeType as aw, inertiaPageOf as ax, install as ay, isExpired 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, Testable as s, componentName as t, live as u, persistentMiddleware as v, AssertableInertia as w, AssertableJson as x, type BatchRecord as y, type BootOptions as z };