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

package/dist/{testing-BErengYY.d.ts → testing-BM481Hdz.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, 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;
-    /** 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, {
@@ -965,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
@@ -978,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;
@@ -1032,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>;
     /**
@@ -1143,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 {
 }
 
 /**
@@ -1188,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`.
@@ -1204,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;
@@ -1219,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).
@@ -1235,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;
 }
 
@@ -1407,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). */
@@ -1428,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;
@@ -1476,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;
 }
@@ -1507,12 +991,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 +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>;
@@ -1587,346 +1071,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. */
@@ -1999,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>;
 }
@@ -2050,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). */
@@ -2154,7 +1308,7 @@ declare const UPDATE_URI = "/oriel/live/update";
  * 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>;
 }
@@ -2264,4 +1418,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 { 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 };