@orieljs/framework 0.1.0-alpha.2 → 0.1.0-alpha.3

package/dist/testing--F6FODc_.d.ts

@@ -0,0 +1,2068 @@
+import { Token as Token$2 } from './contracts.js';
+import { S as ServiceProvider$3, A as Application$2 } from './index.d-DOlTeG-8.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>;
+
+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;
+}
+
+/** 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 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;
+}
+/**
+ * The Inertia page object (protocol v3, @inertiajs/core 3.x). Only component, props, url and version are always
+ * present; the other fields are left out when empty or false.
+ */
+interface InertiaPage {
+    component: string;
+    props: Record<string, unknown>;
+    /** Path and query, never absolute: '/posts?page=2'. */
+    url: string;
+    /** '' 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;
+}
+
+/**
+ * Laravel's PendingCommand: `await t.artisan('inspire').expectsOutput('…').assertExitCode(0)`.
+ * It runs through ConsoleKernel.call() when awaited (or run()), then checks every expectation against the
+ * buffered output (stdout then stderr, as ConsoleKernel.output() returns it) and the exit code.
+ *
+ * The result must be awaited (or run() called): unlike Laravel, where the command runs when the
+ * PendingCommand is destroyed, nothing runs here until then, so an un-awaited `t.artisan(...)` never runs
+ * and checks nothing.
+ */
+declare class PendingCommand implements PromiseLike<number> {
+    private readonly app;
+    readonly command: string;
+    readonly parameters: Record<string, unknown>;
+    private readonly checks;
+    private result;
+    constructor(app: Application$1, 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. */
+    doesntExpectOutput(line?: string): this;
+    expectsOutputToContain(text: string): this;
+    doesntExpectOutputToContain(text: string): this;
+    assertExitCode(code: number): this;
+    assertNotExitCode(code: number): this;
+    assertSuccessful(): this;
+    assertOk(): this;
+    assertFailed(): this;
+    /** Runs the command once and checks the expectations; resolves to the exit code. */
+    run(): Promise<number>;
+    then<R1 = number, R2 = never>(onfulfilled?: ((value: number) => R1 | PromiseLike<R1>) | null, onrejected?: ((reason: unknown) => R2 | PromiseLike<R2>) | null): Promise<R1 | R2>;
+    private execute;
+}
+
+/** A table name, or a model (its table, and its connection when it has one). */
+type TableOrModel = string | ModelInstance;
+
+/** Laravel's JSON structure: `['id', { author: ['name'] }]`, and `'*'` for "every element". */
+type JsonStructure = Array<string | {
+    [key: string]: JsonStructure;
+}> | {
+    [key: string]: JsonStructure;
+};
+
+type Json = unknown;
+type Scope<T extends AssertableJson> = (json: T) => unknown;
+/**
+ * Laravel's Illuminate\Testing\Fluent\AssertableJson: fluent, scoped assertions over decoded JSON. Inside a scope
+ * (has(key, callback), first(), each()) every property must be interacted with, or etc() must be called.
+ */
+declare class AssertableJson {
+    protected readonly props: Json;
+    protected readonly path: string | undefined;
+    protected interactedKeys: string[];
+    constructor(props: Json, path?: string | undefined);
+    static fromJson(json: Json): AssertableJson;
+    /** A child scope of the same class (subclasses override to keep their extra state out of scopes). */
+    protected newScope(props: Json, path: string): AssertableJson;
+    protected dotPath(key?: string): string;
+    /** The value at `key` in this scope, or the whole scope. */
+    protected prop(key?: string): Json;
+    /** A literal key of this scope wins over a dot path, like Laravel's Arr::get (keys such as 'items.0.name'). */
+    private hasOwnKey;
+    private exists;
+    protected interactsWith(key: string | number): void;
+    /** Every property of the scope was checked (called when a scope ends). */
+    interacted(): void;
+    /** Allow the properties this scope didn't check. */
+    etc(): this;
+    /** has('key'), has('key', 3), has('key', json => …), has('key', 3, first => …), or has(3) for the root size. */
+    has(key: string | number, length?: number | Scope<this>, callback?: Scope<this>): this;
+    /** hasAll(['a', 'b']) or hasAll({ items: 3 }). */
+    hasAll(keys: string | string[] | Record<string, number>): this;
+    hasAny(keys: string | string[]): this;
+    missing(key: string): this;
+    missingAll(keys: string | string[]): this;
+    /** count(3) checks this scope's size; count('items', 3) a property's. */
+    count(key: string | number, length?: number): this;
+    countBetween(key: string, min: number, max: number): this;
+    /** where('name', 'Ann'), or where('name', value => value.startsWith('A')). Objects compare ignoring key order. */
+    where(key: string, expected: unknown): this;
+    whereNot(key: string, expected: unknown): this;
+    whereNull(key: string): this;
+    whereNotNull(key: string): this;
+    whereAll(bindings: Record<string, unknown>): this;
+    /** whereType('id', 'integer'), whereType('name', 'string|null'), whereType('tags', ['array', 'null']). */
+    whereType(key: string, expected: string | string[]): this;
+    whereAllType(bindings: Record<string, string | string[]>): this;
+    /** The list contains every expected value (or one passing the callback); a string contains the substring. */
+    whereContains(key: string, expected: unknown): this;
+    protected scope(key: string, callback: Scope<this>): this;
+    first(callback: Scope<this>): this;
+    each(callback: Scope<this>): this;
+    when(condition: unknown, callback: (json: this) => unknown, otherwise?: (json: this) => unknown): this;
+    dump(key?: string): this;
+    toArray(): Json;
+}
+
+/** The page object of a response: the JSON body of an Inertia visit, or the page script of a first visit. */
+declare function inertiaPageOf(response: TestResponse): InertiaPage;
+/** Inertia's AssertableInertia: AssertableJson over the page props, plus the page component, url, version and flash. */
+declare class AssertableInertia extends AssertableJson {
+    #private;
+    static fromTestResponse(response: TestResponse): AssertableInertia;
+    /** Scopes are plain AssertableJson: the page-level methods only make sense at the root. */
+    protected newScope(props: unknown, path: string): AssertableJson;
+    get page(): InertiaPage;
+    /** The component name; the page file must exist unless `shouldExist` is false (inertia.testing.ensure_pages_exist). */
+    component(value?: string, shouldExist?: boolean): this;
+    url(value: string): this;
+    version(value: string): this;
+    /** The flash data has `key` (dot paths allowed), equal to `expected` when given. */
+    hasFlash(key: string, ...expected: [] | [unknown]): this;
+    missingFlash(key: string): this;
+    static assertFlashHas(flash: Record<string, unknown>, key: string, ...expected: [] | [unknown]): void;
+    static assertFlashMissing(flash: Record<string, unknown>, key: string): void;
+    /**
+     * Requests the page again as a partial reload (only/except) and checks it is the same page. Uses the test's
+     * HTTP client, so the session and cookies carry over.
+     */
+    reload(callback?: (page: AssertableInertia) => unknown, only?: string | string[], except?: string | string[]): Promise<this>;
+    reloadOnly(only: string | string[], callback?: (page: AssertableInertia) => unknown): Promise<this>;
+    reloadExcept(except: string | string[], callback?: (page: AssertableInertia) => unknown): Promise<this>;
+    /** Loads the deferred props of every group (or the given groups) in one partial reload. */
+    loadDeferredProps(groupsOrCallback: string | string[] | ((page: AssertableInertia) => unknown), callback?: (page: AssertableInertia) => unknown): Promise<this>;
+    toArray(): Record<string, unknown>;
+}
+
+/** Laravel's CookieValuePrefix: hmac_sha1(name + 'v2', key) + '|' (41 characters), as Auth's EncryptCookies writes it. */
+declare function cookiePrefix(name: string, key: Uint8Array): string;
+/** What EncryptCookies puts in a browser cookie: encrypt(prefix + value, serialize: false). */
+declare function encryptCookie(encrypter: Encrypter, name: string, value: string): string;
+/** The plain value of an encrypted cookie, or undefined when it doesn't decrypt or its prefix is wrong. */
+declare function decryptCookie(encrypter: Encrypter, name: string, value: string): string | undefined;
+interface ResponseCookie {
+    name: string;
+    /** URI-decoded, still encrypted if the app encrypted it. */
+    value: string;
+    path?: string;
+    domain?: string;
+    maxAge?: number;
+    expires?: Date;
+    httpOnly: boolean;
+    secure: boolean;
+    sameSite?: string;
+}
+/** Max-Age <= 0 or an Expires in the past: the server is deleting the cookie. */
+declare function isExpired(cookie: ResponseCookie, now?: number): boolean;
+declare function responseCookies(response: Response): ResponseCookie[];
+declare function cookieHeader(cookies: Map<string, string>): string;
+
+/** Field → messages, as Http flashes them per bag: `errors: { [bag]: { field: string[] } }`. */
+type ErrorMessages = Record<string, string[]>;
+/** `'email'`, `['email', 'name']` or `{ email: 'must be valid' }` (message fragments). */
+type ExpectedErrors = string | string[] | Record<string, string | string[]>;
+/** What the HTTP client knows about the request that produced a response. */
+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;
+    /** The request's session after the response. */
+    session?: Session$1;
+    /** Views made while handling the request, in order. */
+    views?: View[];
+    /** The last error the exception handler rendered. */
+    exception?: unknown;
+    /** The client that sent the request (Inertia reloads reuse it, keeping the session and cookies). */
+    client?: HttpClient;
+}
+/** Laravel's TestResponse: a Response with its body already read, plus fluent assertions. */
+declare class TestResponse {
+    readonly baseResponse: Response;
+    readonly content: string;
+    readonly context: ResponseContext;
+    private decoded;
+    constructor(baseResponse: Response, content: string, context?: ResponseContext);
+    /** Reads the body once, so every assertion is synchronous. */
+    static from(response: Response, context?: ResponseContext): Promise<TestResponse>;
+    get status(): number;
+    get headers(): Headers;
+    /** The error the exception handler rendered for this request, if any. */
+    get exception(): unknown;
+    getContent(): string;
+    /** The decoded JSON body, or the value at a dot path (`data.0.id`). */
+    json<T = unknown>(path?: string): T;
+    dump(path?: string): this;
+    assertStatus(status: number): this;
+    assertOk(): this;
+    assertCreated(): this;
+    assertAccepted(): this;
+    assertMovedPermanently(): this;
+    assertFound(): this;
+    assertNotModified(): this;
+    assertBadRequest(): this;
+    assertUnauthorized(): this;
+    assertPaymentRequired(): this;
+    assertForbidden(): this;
+    assertNotFound(): this;
+    assertMethodNotAllowed(): this;
+    assertNotAcceptable(): this;
+    assertRequestTimeout(): this;
+    assertConflict(): this;
+    assertGone(): this;
+    assertUnsupportedMediaType(): this;
+    assertUnprocessable(): this;
+    assertTooManyRequests(): this;
+    assertInternalServerError(): this;
+    assertServiceUnavailable(): this;
+    /** 204 (or `status`) with an empty body. */
+    assertNoContent(status?: number): this;
+    assertSuccessful(): this;
+    assertClientError(): this;
+    assertServerError(): this;
+    /** A redirect status (201, 301, 302, 303, 307, 308); with `uri`, the Location must match it. */
+    assertRedirect(uri?: string): this;
+    assertRedirectContains(uri: string): this;
+    /** Relative and absolute forms of the same URL are equal (both are resolved against the request URL). */
+    assertLocation(uri: string): this;
+    assertHeader(name: string, value?: string): this;
+    assertHeaderMissing(name: string): this;
+    /** Content-Disposition: attachment (optionally with this file name). */
+    assertDownload(filename?: string): this;
+    assertContent(value: string): this;
+    /** The content contains the value(s); values are HTML-escaped first unless `escape` is false (Laravel). */
+    assertSee(value: string | string[], escape?: boolean): this;
+    assertDontSee(value: string | string[], escape?: boolean): this;
+    assertSeeInOrder(values: string[], escape?: boolean): this;
+    /** Like assertSee, against the content with its tags stripped. */
+    assertSeeText(value: string | string[], escape?: boolean): this;
+    assertDontSeeText(value: string | string[], escape?: boolean): this;
+    assertSeeTextInOrder(values: string[], escape?: boolean): this;
+    /**
+     * The response JSON contains `data` (a subset match: extra keys in the response are fine), or fluent
+     * assertions: assertJson(json => json.has('data', 3).etc()).
+     */
+    assertJson(data: Record<string, unknown> | unknown[] | ((json: AssertableJson) => unknown)): this;
+    /**
+     * An Inertia page response, with optional fluent assertions over its props. An async callback (reload(),
+     * loadDeferredProps()) makes this return a promise: await it.
+     */
+    assertInertia(callback: (page: AssertableInertia) => Promise<unknown>): Promise<this>;
+    assertInertia(callback?: (page: AssertableInertia) => unknown): this;
+    /** The Inertia page object of this response. */
+    inertiaPage(): InertiaPage;
+    /** The page props, or one prop by dot path. */
+    inertiaProps<T = unknown>(key?: string): T;
+    /** Inertia flash data waiting in the session for the next page (after a redirect). */
+    assertInertiaFlash(key: string, ...expected: [] | [unknown]): this;
+    assertInertiaFlashMissing(key: string): this;
+    /** The response JSON equals `data` exactly (object key order is ignored). */
+    assertExactJson(data: unknown): this;
+    /** The value at `path` equals `expected` (strictly), or passes the predicate. */
+    assertJsonPath(path: string, expected: unknown): this;
+    assertJsonMissingPath(path: string): this;
+    /** Each key/value pair appears somewhere in the JSON (Laravel's assertJsonFragment). */
+    assertJsonFragment(data: Record<string, unknown>): this;
+    /** Passes when at least one pair of `data` is absent (Laravel's assertJsonMissing). */
+    assertJsonMissing(data: Record<string, unknown>): this;
+    /** `['id', { author: ['name'] }]`, `{ data: { '*': ['id'] } }`; without a structure, just checks it's JSON. */
+    assertJsonStructure(structure?: JsonStructure): this;
+    /** The JSON (or the value at `key`) has `count` elements. */
+    assertJsonCount(count: number, key?: string): this;
+    /** assertRedirect() to the URL of a named route (resolved with the app's UrlGenerator). */
+    assertRedirectToRoute(name: string, parameters?: unknown): this;
+    /** The JSON body has validation errors for these keys (and messages containing these fragments). */
+    assertJsonValidationErrors(errors: ExpectedErrors, responseKey?: string): this;
+    /** No validation errors in the JSON (or none for these keys). */
+    assertJsonMissingValidationErrors(keys?: string | string[], responseKey?: string): this;
+    /** No validation errors: JSON responses are checked in the body, others in the session. */
+    assertValid(keys?: string | string[], errorBag?: string, responseKey?: string): this;
+    /** 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;
+    /** 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;
+    assertSessionMissing(key: string | string[], value?: unknown): this;
+    /** Old input flashed with the redirect (withInput()). */
+    assertSessionHasInput(key: string | string[] | Record<string, unknown>, value?: unknown): this;
+    /**
+     * The session has errors in `errorBag`: any at all, these keys, or these exact messages (Laravel's rules).
+     * `format` is a ':message' template applied to the actual messages first.
+     */
+    assertSessionHasErrors(keys?: ExpectedErrors, format?: string, errorBag?: string): this;
+    assertSessionHasErrorsIn(errorBag: string, keys?: ExpectedErrors, format?: string): this;
+    /** No errors in any bag. */
+    assertSessionHasNoErrors(): this;
+    /** No errors in the bag (or none for these keys). */
+    assertSessionDoesntHaveErrors(keys?: string | string[], format?: string, errorBag?: string): this;
+    /** A cookie the response sets (the last Set-Cookie with that name). */
+    getCookie(name: string): ResponseCookie | undefined;
+    /** The cookie is set; with `value`, its (decrypted, unless `encrypted` is false) value matches. */
+    assertCookie(name: string, value?: string, encrypted?: boolean): this;
+    assertPlainCookie(name: string, value?: string): this;
+    assertCookieExpired(name: string): this;
+    assertCookieNotExpired(name: string): this;
+    assertCookieMissing(name: string): this;
+    /**
+     * The view the route returned. A request can make other views too (a mailable's, an error page), so this is the
+     * last view whose rendered HTML is the response body, else the last view made.
+     */
+    get original(): View | undefined;
+    assertViewIs(name: string): this;
+    /** The view received `key` (dot paths allowed), optionally with this value or passing this predicate. */
+    assertViewHas(key: string | string[] | Record<string, unknown>, value?: unknown): this;
+    assertViewHasAll(bindings: string[] | Record<string, unknown>): this;
+    assertViewMissing(key: string): this;
+    /** The data the view received (dot path), or all of it. */
+    viewData<T = unknown>(key?: string): T;
+    protected absolute(url: string): string;
+    protected excerpt(text?: string): string;
+    /** Adds the rendered exception (or the body) to a status failure, like Laravel does. */
+    protected statusMessage(message: string): string;
+    protected isJson(): boolean;
+    protected sessionErrors(errorBag: string): ErrorMessages;
+    private formatted;
+    /** Laravel's assertInvalid/assertJsonValidationErrors: each key present; each expected fragment contained in a message. */
+    private assertErrorsContain;
+    private ensureView;
+    private viewDataOf;
+    private decrypted;
+    private needles;
+    private inOrder;
+}
+
+type RequestData = Record<string, unknown>;
+interface RequestOptions {
+    data?: RequestData;
+    headers?: Record<string, string>;
+    /** Send data as a JSON body (the *Json methods). */
+    json?: boolean;
+}
+/**
+ * Laravel's MakesHttpRequests state for one test: default headers, cookies, the session carried between
+ * requests, actingAs users and options, plus the dispatch itself.
+ */
+declare class HttpClient {
+    protected readonly app: Application$1;
+    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, {
+        value: string;
+        encrypt: boolean;
+    }>;
+    /** actingAs() users by guard name (undefined = the default guard). */
+    readonly users: Map<string | undefined, Authenticatable>;
+    followRedirects: boolean;
+    handleExceptions: boolean;
+    /** The guard actingAs(user, guard) made the default. */
+    defaultGuard: string | undefined;
+    /** Session attributes carried from one request to the next (Laravel keeps one session store per test). */
+    session: Record<string, unknown> | undefined;
+    /** from(url): the session's previous URL for the next request only (Laravel sets it once). */
+    previousUrl: string | undefined;
+    /** Requests whose actingAs users reached the guards (the AuthFactory they went through). */
+    private readonly actingAsApplied;
+    constructor(app: Application$1);
+    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>;
+    /** 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;
+    /** 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>;
+    /**
+     * 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;
+    buildRequest(method: string, uri: string, options: RequestOptions): Request;
+    protected baseUrl(): string;
+    protected cookieHeader(): string;
+    /** Like a browser: cookies the app sets are sent back on later requests in the same test; deleted ones are dropped. */
+    protected rememberCookies(response: Response): void;
+}
+/** `{ user: { name: 'a' }, tags: ['x'] }` → `user[name]=a`, `tags[0]=x` (the PHP bracket form Http parses). */
+declare function flatten(data: RequestData, prefix?: string): Array<[string, string | Blob]>;
+
+/** The test runner's per-test hooks. Pass Vitest's: `{ beforeEach, afterEach }`. */
+interface TestHooks {
+    beforeEach(fn: () => unknown): void;
+    afterEach(fn: () => unknown): void;
+}
+/** A Laravel-style trait (RefreshDatabase, …): setUp runs after the app boots; clean-up goes in beforeApplicationDestroyed. */
+interface TestTrait {
+    setUp(test: InteractsWithApplication): void | Promise<void>;
+}
+interface BootOptions {
+    hooks?: TestHooks;
+    /** Extra traits for this file, like `use RefreshDatabase;`. */
+    uses?: TestTrait[];
+}
+type Callback = () => void | Promise<void>;
+/**
+ * Laravel's TestCase lifecycle: a brand-new application for every test (createApplication() → boot → traits),
+ * and a full teardown after it, so no state survives from one test to the next.
+ */
+declare abstract class InteractsWithApplication {
+    /** Set once in tests/TestCase.ts: `static override hooks = { beforeEach, afterEach }` (from vitest). */
+    static hooks?: TestHooks;
+    /** Traits this test case uses (Laravel's `use RefreshDatabase;`). */
+    readonly uses: TestTrait[];
+    private application;
+    private extraTraits;
+    private destroying;
+    /**
+     * Creates the test case and registers its setUp/tearDown as beforeEach/afterEach hooks.
+     * `const t = TestCase.boot()` at the top of a test file (or inside a describe block).
+     */
+    static boot<T extends InteractsWithApplication>(this: (new () => T) & {
+        hooks?: TestHooks;
+    }, options?: BootOptions): T;
+    /** The current test's application. */
+    get app(): Application$1;
+    /**
+     * 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>;
+    /** Used by the default createApplication(). */
+    protected basePath(): string;
+    /** Used by the default createApplication(). */
+    protected providers(): Array<ServiceProvider$2 | ServiceProviderClass$1>;
+    /** 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>;
+    setUp(): Promise<void>;
+    tearDown(): Promise<void>;
+    /** Runs in tearDown(), before the application is thrown away (in registration order). */
+    beforeApplicationDestroyed(callback: Callback): void;
+}
+
+type Headers$1 = Record<string, string>;
+/** Laravel's MakesHttpRequests: requests run in-process through the app's HttpKernel. State lasts for one test. */
+declare abstract class MakesHttpRequests extends InteractsWithApplication {
+    private client;
+    /** The current test's HTTP client (created on first use). */
+    protected get http(): HttpClient;
+    protected createHttpClient(): HttpClient;
+    tearDown(): Promise<void>;
+    withHeaders(headers: Headers$1): this;
+    withHeader(name: string, value: string): this;
+    withToken(token: string, type?: string): this;
+    withBasicAuth(username: string, password: string): this;
+    /** Removes the Authorization header, whatever case it was set with (header names are case-insensitive). */
+    withoutToken(): this;
+    /** Cookies are encrypted the way EncryptCookies expects when the app has an Encrypter. */
+    withCookies(cookies: Record<string, string>): this;
+    withCookie(name: string, value: string): this;
+    withUnencryptedCookies(cookies: Record<string, string>): this;
+    withUnencryptedCookie(name: string, value: string): this;
+    /** Follow redirects (always with GET, like Laravel) and return the final response. */
+    followingRedirects(): this;
+    /** Sets the Referer and the session's previous URL, so redirect()->back() goes there. */
+    from(url: string): this;
+    /** Puts data in the session for the following requests (Laravel's withSession()). */
+    withSession(data: Record<string, unknown>): this;
+    /** Empties the session carried between requests. */
+    flushSession(): this;
+    /** Every following request is authenticated as `user` on `guard` (which also becomes the default guard). */
+    actingAs(user: Authenticatable, guard?: string): this;
+    be(user: Authenticatable, guard?: string): this;
+    /** Errors escape from the request instead of being rendered (Laravel's withoutExceptionHandling()). */
+    withoutExceptionHandling(): this;
+    withExceptionHandling(): this;
+    /** The user is authenticated (after the requests so far: carried session and actingAs). */
+    assertAuthenticated(guard?: string): Promise<this>;
+    assertGuest(guard?: string): Promise<this>;
+    /** Same identifier and class as `user`. */
+    assertAuthenticatedAs(user: Authenticatable, guard?: string): Promise<this>;
+    protected isAuthenticated(guard?: string): Promise<boolean>;
+    get(uri: string, headers?: Headers$1): Promise<TestResponse>;
+    getJson(uri: string, headers?: Headers$1): Promise<TestResponse>;
+    post(uri: string, data?: RequestData, headers?: Headers$1): Promise<TestResponse>;
+    postJson(uri: string, data?: RequestData, headers?: Headers$1): Promise<TestResponse>;
+    put(uri: string, data?: RequestData, headers?: Headers$1): Promise<TestResponse>;
+    putJson(uri: string, data?: RequestData, headers?: Headers$1): Promise<TestResponse>;
+    patch(uri: string, data?: RequestData, headers?: Headers$1): Promise<TestResponse>;
+    patchJson(uri: string, data?: RequestData, headers?: Headers$1): Promise<TestResponse>;
+    delete(uri: string, data?: RequestData, headers?: Headers$1): Promise<TestResponse>;
+    deleteJson(uri: string, data?: RequestData, headers?: Headers$1): Promise<TestResponse>;
+    options(uri: string, data?: RequestData, headers?: Headers$1): Promise<TestResponse>;
+    head(uri: string, headers?: Headers$1): Promise<TestResponse>;
+    /** A JSON request with any verb; GET/HEAD data goes into the query string. */
+    json(method: string, uri: string, data?: RequestData, headers?: Headers$1): Promise<TestResponse>;
+    /** Any verb with form data (Laravel's call()). */
+    call(method: string, uri: string, data?: RequestData, headers?: Headers$1): Promise<TestResponse>;
+}
+
+/** Laravel's InteractsWithDatabase: database assertions and seeding, plus the options RefreshDatabase reads. */
+declare abstract class InteractsWithDatabase extends MakesHttpRequests {
+    /** Seed after RefreshDatabase/DatabaseMigrations migrate (Laravel's $seed). */
+    seed: boolean;
+    /** Seed with this seeder class instead of DatabaseSeeder (Laravel's $seeder). */
+    seeder: string | undefined;
+    /** Connections RefreshDatabase/DatabaseTransactions wrap in a transaction (undefined = the default connection). */
+    connectionsToTransact: Array<string | undefined>;
+    protected get database(): DatabaseManager;
+    assertDatabaseHas(table: TableOrModel, data: Row, connection?: string): Promise<this>;
+    assertDatabaseMissing(table: TableOrModel, data: Row, connection?: string): Promise<this>;
+    assertDatabaseCount(table: TableOrModel, count: number, connection?: string): Promise<this>;
+    assertDatabaseEmpty(table: TableOrModel, connection?: string): Promise<this>;
+    assertModelExists(model: ModelInstance): Promise<this>;
+    assertModelMissing(model: ModelInstance): Promise<this>;
+    assertSoftDeleted(table: TableOrModel, data?: Row, connection?: string, deletedAtColumn?: string): Promise<this>;
+    assertNotSoftDeleted(table: TableOrModel, data?: Row, connection?: string, deletedAtColumn?: string): Promise<this>;
+    /** Runs `db:seed` (with a seeder class name, like Laravel's $this->seed(UserSeeder::class)). */
+    runSeeder(seeder?: string): Promise<this>;
+}
+
+/** Laravel's InteractsWithConsole: `await t.artisan('cmd', { user: 1, '--queue': 'high' }).assertExitCode(0)`. */
+declare abstract class InteractsWithConsole extends InteractsWithDatabase {
+    /** The command runs when the returned PendingCommand is awaited; without `await` it never runs. */
+    artisan(command: string, parameters?: Record<string, unknown>): PendingCommand;
+}
+
+/**
+ * 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 {
+}
+
+/**
+ * Laravel's phpunit.xml <env> block. Applied before every test's application is created; variables that are
+ * already set (the shell, CI, vitest.config) win, like phpunit's non-forced <env>.
+ */
+declare const TESTING_ENVIRONMENT: Readonly<Record<string, string>>;
+declare function applyEnvironment(values: Record<string, string>, env?: NodeJS.ProcessEnv): void;
+
+/** The request scope's ViewFactory: records every view made, so TestResponse can assert on it (assertViewIs/Has). */
+declare function recordingViewFactory(factory: ViewFactory, views: View[]): ViewFactory;
+/**
+ * The request scope's ExceptionHandler: records the error it renders (for failure messages and
+ * withoutExceptionHandling()), then renders it as usual.
+ */
+declare function recordingExceptionHandler(handler: ExceptionHandler, record: (error: unknown) => void): ExceptionHandler;
+/**
+ * The request scope's AuthFactory for actingAs(): the users are put on the scope's guards the first time
+ * anything touches auth. That is after the kernel bound HttpRequest, so request.user() sees them too.
+ * `onApply` runs when that happens, so the client knows to read the guards back after the request.
+ */
+declare function actingAsAuthFactory(auth: AuthFactory, users: Map<string | undefined, Authenticatable>, defaultGuard: string | undefined, onApply?: () => void): AuthFactory;
+
+/** Options a test case may declare (InteractsWithDatabase declares them): Laravel's $seed, $seeder, $connectionsToTransact. */
+interface DatabaseTestOptions {
+    seed?: boolean;
+    seeder?: string;
+    connectionsToTransact?: Array<string | undefined>;
+    /**
+     * Replaces the once-per-process `migrate:fresh` that RefreshDatabase runs on a file or server database, for a test
+     * case that must not wipe the whole database. It must leave the schema migrated, and seeded when seed/seeder ask
+     * for it. (Laravel's migrateFreshUsing() returns options for migrate:fresh; here it replaces the command.)
+     */
+    migrateFreshUsing?(): void | Promise<void>;
+}
+/** Laravel's RefreshDatabaseState: the schema is migrated once per process (per worker). */
+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>;
+/** Laravel's usingInMemoryDatabase(): the default connection's database is ':memory:'. */
+declare function usingInMemoryDatabase(app: Application$1): boolean;
+/**
+ * Laravel's RefreshDatabase.
+ * - In-memory SQLite: every test's new application has an empty database, so it just runs `migrate`.
+ * - Otherwise: `migrate:fresh` once per process (or the test's own migrateFreshUsing()), then each test runs inside a
+ *   transaction that is rolled back.
+ */
+declare const RefreshDatabase: TestTrait;
+/** Laravel's DatabaseMigrations: `migrate:fresh` before each test, `migrate:rollback` after it. */
+declare const DatabaseMigrations: TestTrait;
+/** Laravel's DatabaseTransactions: each test runs in a transaction that is rolled back (no migrations). */
+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;
+/** 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 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;
+
+/** One dispatch: the event object (or name) and its payload. */
+interface DispatchedEvent {
+    event: object | string;
+    payload: unknown[];
+}
+type EventFilter<E> = (event: E, payload: unknown[]) => boolean;
+/**
+ * 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).
+ */
+declare class EventFake implements EventDispatcher {
+    readonly dispatcher: EventDispatcher | undefined;
+    private readonly eventsToFake;
+    private eventsToDispatch;
+    readonly events: DispatchedEvent[];
+    constructor(dispatcher: EventDispatcher | undefined, eventsToFake?: Target[], eventsToDispatch?: Target[]);
+    /** Installs the fake (on the current container) and returns it: `const events = EventFake.fake([OrderShipped])`. */
+    static fake(eventsToFake?: Target | Target[]): EventFake;
+    /** Fakes every event except these. */
+    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;
+    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(events: EventDispatcher): void;
+    }>): void;
+    forget(event: Class$1<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;
+    assertNothingDispatched(): void;
+    /** The original dispatcher has a listener for the event. */
+    assertListening(event: Class$1<unknown> | string): 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;
+    private shouldFake;
+}
+
+type Filter$3<J> = (job: J) => boolean;
+/** What a faked Bus.batch([...]).dispatch() recorded (Laravel's PendingBatchFake): the options Bus would store, plus the jobs. */
+interface BatchRecord extends PendingBatchOptions {
+    readonly id: string;
+    readonly jobs: Job[];
+}
+/**
+ * Laravel's Bus::fake(): records dispatch/dispatchSync/dispatchAfterResponse, chains and batches instead of
+ * running or queueing them. With a list, only those jobs are faked; others go to the original dispatcher.
+ */
+declare class BusFake implements BusDispatcher {
+    readonly dispatcher: BusDispatcher | undefined;
+    private readonly jobsToFake;
+    private jobsToDispatch;
+    readonly commands: Job[];
+    readonly commandsSync: Job[];
+    readonly commandsAfterResponse: Job[];
+    readonly batches: BatchRecord[];
+    /** The rest of the chain, by the first job (Bus.chain([a, b, c]) records a with [b, c]). */
+    readonly chains: Map<Job, Job[]>;
+    constructor(dispatcher: BusDispatcher | undefined, jobsToFake?: Target[], jobsToDispatch?: Target[]);
+    static fake(jobsToFake?: Target | Target[]): BusFake;
+    static fakeExcept(jobsToDispatch: Target | Target[]): BusFake;
+    private static original;
+    except(jobs: Target | Target[]): this;
+    dispatch(job: Job): Promise<unknown>;
+    dispatchSync(job: Job): Promise<unknown>;
+    dispatchAfterResponse(job: Job): void;
+    /**
+     * Bus's terminating callback flushes whatever BusDispatcher is bound, which is this fake: forward to the real
+     * dispatcher so the after-response jobs it didn't fake still run (Laravel runs them). Faked ones never run.
+     */
+    flushAfterResponse(): Promise<void>;
+    chain(jobs: Job[]): PendingChain;
+    batch(jobs: Job[]): PendingBatch;
+    findBatch(id: string): Promise<Batch | undefined>;
+    /** Dispatched in any way (dispatch, dispatchSync or dispatchAfterResponse); a number asserts the count. */
+    assertDispatched<J extends Job>(job: Target<J>, callback?: CountOrFilter<[J]>): void;
+    assertDispatchedTimes<J extends Job>(job: Target<J>, times?: number): void;
+    assertNotDispatched<J extends Job>(job: Target<J>, callback?: Filter$3<J>): void;
+    assertNothingDispatched(): void;
+    assertDispatchedSync<J extends Job>(job: Target<J>, callback?: CountOrFilter<[J]>): void;
+    assertNotDispatchedSync<J extends Job>(job: Target<J>, callback?: Filter$3<J>): void;
+    assertDispatchedAfterResponse<J extends Job>(job: Target<J>, callback?: CountOrFilter<[J]>): void;
+    assertNotDispatchedAfterResponse<J extends Job>(job: Target<J>, callback?: Filter$3<J>): void;
+    /** `[First, Second, new Third(1)]`: a dispatched First whose chain is exactly the rest (classes or equal instances). */
+    assertChained(expectedChain: Array<Target | Job>): void;
+    assertDispatchedWithoutChain<J extends Job>(job: Target<J>, callback?: Filter$3<J>): void;
+    /** A batch was dispatched that passes the check. */
+    assertBatched(callback: (batch: BatchRecord) => boolean): void;
+    assertBatchCount(count: number): void;
+    assertNothingBatched(): void;
+    dispatched<J extends Job>(job: Target<J>, callback?: Filter$3<J>): J[];
+    dispatchedSync<J extends Job>(job: Target<J>, callback?: Filter$3<J>): J[];
+    dispatchedAfterResponse<J extends Job>(job: Target<J>, callback?: Filter$3<J>): J[];
+    hasDispatched<J extends Job>(job: Target<J>): boolean;
+    private shouldFake;
+    private real;
+}
+
+/** One push: the job (or raw payload), where it went, and when. */
+interface PushedJob {
+    job: Job | QueuePayload;
+    raw: boolean;
+    connection: string | undefined;
+    queue: string | undefined;
+    delay: number | undefined;
+}
+type Filter$2<J> = (job: J, queue: string | undefined, connection: string | undefined) => boolean;
+/**
+ * Laravel's Queue::fake(): records push/later/pushRaw (on any connection) instead of queueing. Jobs that Bus
+ * dispatches to a queue land here too, because Bus resolves QueueManager when it queues.
+ */
+declare class QueueFake implements QueueManager {
+    readonly manager: QueueManager | undefined;
+    private readonly jobsToFake;
+    private jobsToPush;
+    readonly jobs: PushedJob[];
+    constructor(manager: QueueManager | undefined, jobsToFake?: Target[], jobsToPush?: Target[]);
+    static fake(jobsToFake?: Target | Target[]): QueueFake;
+    static fakeExcept(jobsToPush: Target | Target[]): QueueFake;
+    private static original;
+    except(jobs: Target | Target[]): this;
+    /**
+     * A recording view of the connection (pushes remember its name). Its size()/clear() only see the jobs pushed
+     * through that connection name (no name: the jobs pushed without one, i.e. through the manager or connection()).
+     */
+    connection(name?: string): 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>;
+    /** Jobs on `queue` (every queue when omitted), whatever connection they were pushed on, like Laravel's fake. */
+    size(queue?: string): Promise<number>;
+    /** Removes the jobs size() counts and returns how many. */
+    clear(queue?: string): Promise<number>;
+    extend(_driver: string, _factory: (config: Record<string, unknown>) => Queue): void;
+    /** Pushed at least once; a number asserts the count; a filter gets (job, queue, connection). */
+    assertPushed<J extends Job>(job: Target<J>, callback?: CountOrFilter<[J, string | undefined, string | undefined]>): void;
+    assertPushedTimes<J extends Job>(job: Target<J>, times?: number): void;
+    assertPushedOn<J extends Job>(queue: string, job: Target<J>, callback?: Filter$2<J>): void;
+    assertNotPushed<J extends Job>(job: Target<J>, callback?: Filter$2<J>): void;
+    assertNothingPushed(): void;
+    assertCount(expected: number): void;
+    /** The job was pushed with exactly this chain (Bus stores it on the first job under the protocol key). */
+    assertPushedWithChain<J extends Job>(job: Target<J>, expectedChain: Array<Target | Job>, callback?: Filter$2<J>): void;
+    assertPushedWithoutChain<J extends Job>(job: Target<J>, callback?: Filter$2<J>): void;
+    /** Pushed jobs matching the target (raw payloads match by their registry name or display name). */
+    pushed<J extends Job>(job: Target<J>, callback?: Filter$2<J>): J[];
+    hasPushed<J extends Job>(job: Target<J>): boolean;
+    private record;
+    private recordRaw;
+    /** The job is on `queue` (any when undefined) and, when `connection` is given, was pushed on that connection name. */
+    private on;
+    private remove;
+    private targets;
+    private nameOf;
+    private shouldFake;
+    private real;
+}
+
+/** A mailable the fake saw, with its resolved recipients (PendingMail's, else the envelope's) and subject. */
+declare class MailRecord<M extends Mailable = Mailable> {
+    readonly mailable: M;
+    readonly mailer: string | undefined;
+    readonly to: Address[];
+    readonly cc: Address[];
+    readonly bcc: Address[];
+    readonly subject: string | undefined;
+    readonly queued: boolean;
+    readonly delay: number | undefined;
+    constructor(mailable: M, mailer: string | undefined, to: Address[], cc: Address[], bcc: Address[], subject: string | undefined, queued: boolean, delay: number | undefined);
+    hasTo(address: MailRecipient): boolean;
+    hasCc(address: MailRecipient): boolean;
+    hasBcc(address: MailRecipient): boolean;
+    hasSubject(subject: string): boolean;
+}
+type Filter$1<M extends Mailable> = (mailable: M, mail: MailRecord<M>) => boolean;
+/**
+ * Laravel's Mail::fake(): records what would have been sent or queued. Queueable mailables (the Queue/Bus
+ * protocol's rule) sent with send() count as queued, like the real Mailer. Nothing is rendered or delivered.
+ */
+declare class MailFake implements MailManager {
+    readonly manager: MailManager | undefined;
+    readonly records: MailRecord[];
+    constructor(manager?: MailManager | undefined);
+    static fake(): MailFake;
+    mailer(name?: string): Mailer;
+    to(recipients: MailRecipient | MailRecipient[]): PendingMail;
+    send(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). */
+    assertSent<M extends Mailable>(mailable: Target<M>, callback?: CountOrFilter<[M, MailRecord<M>]>): void;
+    assertSentTimes<M extends Mailable>(mailable: Target<M>, times?: number): void;
+    assertNotSent<M extends Mailable>(mailable: Target<M>, callback?: Filter$1<M>): void;
+    assertNothingSent(): void;
+    assertSentCount(count: number): void;
+    assertQueued<M extends Mailable>(mailable: Target<M>, callback?: CountOrFilter<[M, MailRecord<M>]>): void;
+    assertNotQueued<M extends Mailable>(mailable: Target<M>, callback?: Filter$1<M>): void;
+    assertNothingQueued(): void;
+    assertQueuedCount(count: number): void;
+    /** Sent or queued. */
+    assertOutgoingCount(count: number): void;
+    assertNothingOutgoing(): void;
+    sent<M extends Mailable>(mailable: Target<M>, callback?: Filter$1<M>): M[];
+    queued<M extends Mailable>(mailable: Target<M>, callback?: Filter$1<M>): M[];
+    hasSent(mailable: Target<Mailable>): boolean;
+    hasQueued(mailable: Target<Mailable>): boolean;
+    private pending;
+    private sendVia;
+    private queueVia;
+    private record;
+    private matching;
+}
+/** MailRecipient(s) → Address[] (strings, Address objects, or anything with email + name, such as a User model). */
+declare function addresses(recipients: MailRecipient | MailRecipient[]): Address[];
+
+/** One delivery the fake recorded: to whom, what, and on which channels (the notification's via()). */
+interface SentNotification {
+    notifiable: Notifiable;
+    notification: Notification;
+    channels: string[];
+}
+type Filter<N extends Notification> = (notification: N, channels: string[], notifiable: Notifiable) => boolean;
+/** Notification.route('mail', 'a@b.c'): an on-demand notifiable (Laravel's AnonymousNotifiable). */
+declare class AnonymousNotifiable implements Notifiable {
+    private readonly dispatcher;
+    readonly routes: Map<string, unknown>;
+    constructor(dispatcher: NotificationDispatcher);
+    route(channel: string, route: unknown): this;
+    routeNotificationFor(channel: string): unknown;
+    notify(notification: Notification): Promise<void>;
+}
+/**
+ * Laravel's Notification::fake(): records notifications (send, sendNow, on-demand routes) instead of
+ * delivering or queueing them. The Notifiable mixin's notify() resolves the dispatcher per call, so it lands here.
+ */
+declare class NotificationFake implements NotificationDispatcher {
+    readonly dispatcher: NotificationDispatcher | undefined;
+    readonly notifications: SentNotification[];
+    constructor(dispatcher?: NotificationDispatcher | undefined);
+    static fake(): NotificationFake;
+    send(notifiables: Notifiable | Iterable<Notifiable>, notification: Notification): Promise<void>;
+    sendNow(notifiables: Notifiable | Iterable<Notifiable>, notification: Notification, channels?: string[]): Promise<void>;
+    route(channel: string, route: unknown): AnonymousNotifiable;
+    /** The Notifications provider calls this in boot(); a fake has no channels to register. */
+    extend(_channel: string, _factory: () => NotificationChannel): void;
+    /** Sent to the notifiable(s); a number asserts the count; a filter gets (notification, channels, notifiable). */
+    assertSentTo<N extends Notification>(notifiable: Notifiable | Iterable<Notifiable>, notification: Target<N>, callback?: CountOrFilter<[N, string[], Notifiable]>): void;
+    assertSentToTimes<N extends Notification>(notifiable: Notifiable, notification: Target<N>, times?: number): void;
+    assertNotSentTo<N extends Notification>(notifiable: Notifiable | Iterable<Notifiable>, notification: Target<N>, callback?: Filter<N>): void;
+    /** Sent through Notification.route(...) (an anonymous notifiable). */
+    assertSentOnDemand<N extends Notification>(notification: Target<N>, callback?: CountOrFilter<[N, string[], AnonymousNotifiable]>): void;
+    assertNothingSent(): void;
+    assertNothingSentTo(notifiable: Notifiable): void;
+    /** 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[];
+    hasSent(notifiable: Notifiable, notification: Target<Notification>): boolean;
+    private record;
+}
+
+interface StoredFile {
+    bytes: Uint8Array;
+    visibility: 'public' | 'private';
+    mimeType: string | undefined;
+    modified: Date;
+}
+declare function guessMimeType(path: string): string | undefined;
+/**
+ * An in-memory disk implementing the Filesystem contract, with Laravel's fake-disk assertions. (Laravel's fake
+ * writes to storage/framework/testing/disks; this one keeps files in memory, so there's nothing to clean up.)
+ */
+declare class FakeDisk implements Filesystem {
+    readonly name: string;
+    private readonly urlPrefix;
+    /** Stored files by normalized path. */
+    readonly stored: Map<string, StoredFile>;
+    /** Directories made explicitly (others exist because files are in them). */
+    readonly made: Set<string>;
+    constructor(name: string, urlPrefix?: string);
+    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>;
+    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>;
+    /** A virtual absolute path (the files only exist in memory). */
+    path(path: string): string;
+    /** The file(s) exist; with `content`, the (single) file has exactly that content. */
+    assertExists(path: string | string[], content?: string): Promise<this>;
+    assertMissing(path: string | string[]): Promise<this>;
+    assertDirectoryEmpty(path: string): Promise<this>;
+    assertCount(path: string, count: number, recursive?: boolean): Promise<this>;
+    private read;
+    private isDirectory;
+}
+/**
+ * Laravel's Storage::fake('avatars'): swaps the FilesystemManager for one whose faked disks live in memory
+ * (other disks still reach the real manager). Returns the fake disk.
+ */
+declare class StorageFake implements FilesystemManager {
+    readonly manager: FilesystemManager | undefined;
+    private readonly defaultDisk;
+    readonly disks: Map<string, FakeDisk>;
+    constructor(manager: FilesystemManager | undefined, defaultDisk: string);
+    static fake(disk?: string): FakeDisk;
+    disk(name?: string): Filesystem;
+    extend(driver: string, factory: (config: Record<string, unknown>) => Filesystem): void;
+    exists(path: string): Promise<boolean>;
+    missing(path: string): Promise<boolean>;
+    get(path: string): Promise<string>;
+    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>;
+    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>;
+    path(path: string): string;
+}
+
+/** 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. */
+    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>;
+
+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;
+}
+
+/** 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;
+    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 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. */
+interface QueuedDispatch {
+    name: string;
+    params: Record<string, unknown>;
+    self?: true;
+    to?: string | Class<Component>;
+}
+/** The validation errors of a component (Laravel's MessageBag), for render(): `this.errors.first('title')`. */
+declare class ErrorBag implements MessageBag {
+    private readonly messages;
+    constructor(messages: Record<string, string[]>);
+    has(key: string): boolean;
+    first(key?: string): string | undefined;
+    get(key: string): string[];
+    all(): string[];
+    any(): boolean;
+    isEmpty(): boolean;
+    count(): number;
+    toObject(): Record<string, string[]>;
+}
+/** What dispatch() returns: `this.dispatch('saved').self()` or `.to(Sidebar)`. */
+declare class PendingEvent {
+    private readonly event;
+    constructor(event: QueuedDispatch);
+    /** Only this component's own listeners receive the event. */
+    self(): this;
+    /** Only components of this class (or registered name) receive the event. */
+    to(component: string | Class<Component>): this;
+}
+/**
+ * A Live component (Livewire 3): public fields are its state, public methods are actions the browser can call, and
+ * render() returns its TSX. Lifecycle hooks, all optional: `boot()`, `mount(params)`, `hydrate()`, `dehydrate()`,
+ * `updating(name, value)`/`updated(name, value)` and per property `updatingTitle(value)`/`updatedTitle(value)`,
+ * `rendering()`/`rendered(html)`. Fields that must not be state use `#private` syntax.
+ */
+declare abstract class Component {
+    static readonly [COMPONENT] = true;
+    /** The view that wraps a full-page component (default: config `live.layout`). */
+    static layout?: string;
+    /** The page title passed to the layout as `title`. */
+    static title?: string;
+    /** Static fallbacks for runtimes without decorators: { event: 'method' }, locked names, computed getter names. */
+    static listeners?: Record<string, string>;
+    static locked?: string[];
+    static computed?: string[];
+    abstract render(): unknown;
+    getId(): string;
+    getName(): string;
+    /** Dispatches a browser event; every component listening for it (@On) runs its handler. */
+    dispatch(name: string, params?: Record<string, unknown>): PendingEvent;
+    /** Sends the browser to `url` after this request; `navigate` uses o:navigate instead of a full page load. */
+    redirect(url: string, options?: {
+        navigate?: boolean;
+    }): void;
+    redirectRoute(name: string, parameters?: unknown, options?: {
+        navigate?: boolean;
+    }): void;
+    /**
+     * Validates the public state. On success clears the error bag and returns the validated data; on failure fills the
+     * error bag and throws (the rest of the action is skipped and the component re-renders with `errors`).
+     */
+    validate<T = Record<string, unknown>>(rules: Rules, messages?: Record<string, string>, attributes?: Record<string, string>): Promise<T>;
+    addError(key: string, message: string): void;
+    /** Clears every error, or only those of `keys`. */
+    resetErrorBag(...keys: string[]): void;
+    get errors(): ErrorBag;
+    /** Puts public properties (all of them when none are named) back to their initial values. */
+    reset(...properties: string[]): void;
+    /** Keeps the current HTML: the response carries the new state but no `html` effect. */
+    skipRender(): void;
+    /** A full-page component as a route action: Route.get('/counter', Counter). Route parameters go to mount(). */
+    __invoke(): Promise<unknown>;
+}
+
+/** @On('post-created'): calls the method when the event is dispatched (by this or any component, or the browser). */
+declare function On(event: string): (_method: unknown, context: ClassMethodDecoratorContext) => void;
+/** @Locked: a property the browser can't change, or a method the browser can't call. */
+declare function Locked(_target: unknown, context: ClassFieldDecoratorContext | ClassMethodDecoratorContext): void;
+/** @Computed: a getter cached for the rest of the request, never part of the component's state. */
+declare function Computed<T>(getter: (this: object) => T, context: ClassGetterDecoratorContext): (this: object) => T;
+
+/**
+ * Livewire's Livewire::test(): drives one component through the real mount → snapshot → checksum → update pipeline
+ * (no HTTP). Actions are async (`await counter.call('increment')`); assertions are sync and return `this`.
+ */
+declare class Testable<C extends Component = Component> {
+    #private;
+    private readonly manager;
+    private constructor();
+    /** Mounts `component` with `params`, as `<Live component={…} {...params} />` would. */
+    static create<C extends Component>(component: Class<C> | string, params?: Record<string, unknown>): Promise<Testable<C>>;
+    /** The component instance after the last request. */
+    instance(): C;
+    /** A public property (dotted paths reach into arrays and objects). */
+    get<T = unknown>(path: string): T;
+    /** The last rendered HTML, without the o:id, o:snapshot and o:effects attributes (Livewire strips them too). */
+    html(): string;
+    /** The effects of the last request. */
+    effects(): LiveEffects;
+    set(path: string | Record<string, unknown>, value?: unknown): Promise<this>;
+    call(method: string, ...params: unknown[]): Promise<this>;
+    toggle(path: string): Promise<this>;
+    /** Dispatches an event to this component, as the browser does for its listeners. */
+    dispatch(event: string, params?: Record<string, unknown>): Promise<this>;
+    refresh(): Promise<this>;
+    assertSet(path: string, value: unknown): this;
+    assertNotSet(path: string, value: unknown): this;
+    /** Each value, HTML-escaped, appears in the rendered HTML. */
+    assertSee(...values: string[]): this;
+    assertDontSee(...values: string[]): this;
+    /** Each value appears in the rendered HTML as written (not escaped). */
+    assertSeeHtml(...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). */
+    assertHasErrors(keys?: string | string[]): this;
+    /** No errors for the keys given (or none at all with no keys). */
+    assertHasNoErrors(keys?: string | string[]): this;
+    assertRedirect(url?: string): this;
+    assertNoRedirect(): this;
+    /** The last call returned `value`. */
+    assertReturned(value: unknown): this;
+}
+
+/** Props of `<Live component={Counter} count={3} o:key="c1" />`: the rest become mount params. */
+interface LiveProps {
+    component: Class<Component> | string;
+    /** Identifies a child inside its parent across re-renders (Livewire's :key / wire:key). */
+    'o:key'?: string | number;
+    [param: string]: unknown;
+}
+/** Blade's @livewire('counter', ['count' => 3], key('c1')): the component's first render, as trusted HTML. */
+declare function live(component: Class<Component> | string, params?: Record<string, unknown>, key?: string | number): Promise<Htmlable>;
+/** `<Live component={Counter} />` in any view or component. */
+declare function LiveComponent({ component, 'o:key': key, children: _children, ...params }: LiveProps): Promise<Htmlable>;
+/** The `<Live />` element, and the Live facade: Live.component(name, Class), Live.test(Component). */
+declare const Live: typeof LiveComponent & {
+    /** Registers a component under a name (components in app/Live are registered at boot). */
+    component(name: string, component: Class<Component>): void;
+    /** Livewire::test(): mounts `component` for assertions. */
+    test<C extends Component>(component: Class<C> | string, params?: Record<string, unknown>): Promise<Testable<C>>;
+};
+
+type Call = {
+    method: string;
+    params: unknown[];
+};
+/** One component after a mount or an update: the live instance (for Live.test), its snapshot, effects and HTML. */
+interface ComponentResult {
+    instance: Component;
+    snapshot: LiveSnapshot;
+    effects: LiveEffects;
+    /** The rendered HTML with o:id (and, after a mount, o:snapshot/o:effects); undefined after skipRender(). */
+    html?: string;
+    tag?: string;
+}
+/** Livewire's update request handling and first render, on Oriel's contracts. */
+declare class LiveComponentManager implements LiveManager {
+    private readonly app;
+    constructor(app: Application);
+    /** The request scope when there is one (sessions, the current route), else the application. */
+    private container;
+    private registry;
+    /** Live.component('counter', Counter): registers a component under a name the snapshots use. */
+    register(component: Class<unknown>, name?: string): void;
+    /** The registered name of a component class, registering it under its kebab-case class name the first time. */
+    nameOf(component: Class<Component>): string;
+    resolve(name: string): Class<Component>;
+    isLiveRequest(request: HttpRequest): boolean;
+    /** The first render: HTML with o:id, o:snapshot and o:effects on the root element. */
+    mount(component: string | Class<unknown>, params?: Record<string, unknown>, key?: string): Promise<string>;
+    mountComponent(component: string | Class<unknown>, params?: Record<string, unknown>, existing?: Component): Promise<ComponentResult>;
+    /** Applies each component's updates and calls, re-renders it and returns its new snapshot and effects. */
+    update(request: LiveUpdateRequest): Promise<LiveUpdateResponse>;
+    updateComponent(snapshotJson: string, updates: Record<string, unknown>, calls: Call[]): Promise<ComponentResult>;
+    /** The route action of POST /oriel/live/update. */
+    handle(request: HttpRequest): Promise<LiveUpdateResponse>;
+    /** A full-page component (Route.get('/counter', Counter)): mounted with the route parameters, inside the layout. */
+    page(component: Component): Promise<unknown>;
+    /** Parses and checks a snapshot: a bad checksum throws before anything is hydrated. */
+    private verify;
+    private key;
+    /** The request body, read from the raw JSON when the request has it, so TrimStrings can't alter typed values. */
+    private payload;
+    /** Makes every computed getter (static `computed` too) cache its value for the rest of the request. */
+    private prepareComputed;
+    private applyUpdate;
+    /** Runs one call from the browser: a magic action, an event, or a public method. Returns its return value. */
+    private call;
+    /** Renders the component (rendering/rendered hooks, nested children tracked) and checks for a single root. */
+    private render;
+    /** 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. */
+    private snapshot;
+}
+
+/** 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.
+ */
+declare class LiveServiceProvider extends ServiceProvider {
+    register(): void;
+    boot(): Promise<void>;
+}
+
+/** A component's Livewire name from its path under app/Live: Posts/CreatePost.tsx → posts.create-post. */
+declare function componentName(file: string): string;
+
+/** A Live programming error (unsupported state, a missing root element, an unknown component): a 500. */
+declare class LiveError extends Error implements OrielError {
+    readonly name: string;
+    readonly kind: ErrorKind;
+    readonly status: number;
+}
+/** A snapshot whose checksum doesn't match (tampered with, or signed with another APP_KEY). Nothing is hydrated. */
+declare class CorruptComponentPayloadError extends LiveError {
+    readonly name: string;
+    readonly kind: ErrorKind;
+    readonly status: number;
+    constructor(component?: string);
+}
+/** The browser asked for a method that isn't a public action of the component. */
+declare class MethodNotCallableError extends LiveError {
+    readonly name: string;
+    readonly kind: ErrorKind;
+    readonly status: number;
+    constructor(method: string, component: string);
+}
+/** The browser tried to set a property that is locked, computed, private (`_x`) or not declared. */
+declare class PropertyNotUpdatableError extends LiveError {
+    readonly name: string;
+    readonly kind: ErrorKind;
+    readonly status: number;
+    constructor(path: string, component: string);
+}
+/** A snapshot names a component that isn't registered. */
+declare class LiveComponentNotFoundError extends LiveError {
+    readonly name: string;
+    readonly kind: ErrorKind;
+    readonly status: number;
+    constructor(component: string);
+}
+/** An update request without the X-Oriel-Live header or with a malformed body. */
+declare class InvalidLiveRequestError extends LiveError {
+    readonly name: string;
+    readonly kind: ErrorKind;
+    readonly status: number;
+}
+
+export { type ResponseContext as $, AnonymousNotifiable as A, BusFake as B, Component as C, DatabaseMigrations as D, EventFake as E, FakeDisk as F, InteractsWithConsole as G, HttpClient as H, InvalidLiveRequestError as I, InteractsWithDatabase as J, type JsonStructure as K, Live as L, MailFake as M, NotificationFake as N, On as O, PendingEvent as P, QueueFake as Q, MailRecord as R, MakesHttpRequests as S, type Target as T, UPDATE_URI as U, PendingCommand as V, type PushedJob as W, RefreshDatabase as X, RefreshDatabaseState as Y, type RequestData as Z, type RequestOptions as _, type ComponentResult as a, type ResponseCookie as a0, type SentNotification as a1, StorageFake as a2, TESTING_ENVIRONMENT as a3, type TableOrModel as a4, TestCase as a5, type TestHooks as a6, TestResponse as a7, type TestTrait as a8, actingAsAuthFactory as a9, addresses as aa, applyEnvironment as ab, cookieHeader as ac, cookiePrefix as ad, decryptCookie as ae, encryptCookie as af, flatten as ag, guessMimeType as ah, inertiaPageOf as ai, install as aj, isExpired as ak, matches as al, nameOf as am, recordingExceptionHandler as an, recordingViewFactory as ao, responseCookies as ap, runCommand as aq, usingInMemoryDatabase as ar, 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, PropertyNotUpdatableError as l, Testable as m, componentName as n, live as o, AssertableInertia as p, AssertableJson as q, type BatchRecord as r, type BootOptions as s, type CountOrFilter as t, type DatabaseTestOptions as u, DatabaseTransactions as v, type DispatchedEvent as w, type ExpectedErrors as x, FakeFile as y, InteractsWithApplication as z };