@orieljs/framework 0.1.0-alpha.1 → 0.1.0-alpha.11

package/dist/testing-CKwfWJGn.d.ts

@@ -0,0 +1,1586 @@
+import { BusDispatcher, Job, PendingBatchOptions, Class, PendingChain, PendingBatch, Batch, EventDispatcher, Listener, MailManager, Mailable, Address, MailRecipient, Mailer, PendingMail, SentMessage, MailTransport, NotificationDispatcher, Notifiable, Notification, NotificationChannel, QueueManager, QueuePayload, Queue, QueueJob, FilesystemManager, Filesystem, PutOptions, UploadedFile, Application, Session, View, Authenticatable, Container, AuthFactory, InertiaPage, ServiceProvider, ServiceProviderClass, DatabaseManager, ModelInstance, Row, Encrypter, Token, ExceptionHandler, ViewFactory, RouteName, RouteArguments, Rules, InferValidatedType, MessageBag, LiveSnapshot, LiveEffects, OrielError, ErrorKind, Htmlable, LiveManager, HttpRequest, LiveUpdateRequest, LiveUpdateResponse, MiddlewareClass, Router } from './contracts.js';
+import { S as ServiceProvider$1 } from './index.d-WQpfdIbG.js';
+
+/** A date the tests travel to: a Date, an ISO string or milliseconds since the epoch. */
+type TravelDate = Date | string | number;
+/**
+ * Laravel's travelTo(): the clock stands at `date` (new Date(), Date.now() and now() all read it) until travelBack().
+ * With a callback, it runs there and the clock travels back after it; its result is returned.
+ */
+declare function travelTo(date: TravelDate): void;
+declare function travelTo<R>(date: TravelDate, callback: (date: Date) => R): R;
+/** Laravel's travelBack(): the real clock again. Returns the real time. */
+declare function travelBack(): Date;
+/** Laravel's freezeTime(): holds the clock where it is now. Returns that time, or the callback's result. */
+declare function freezeTime(): Date;
+declare function freezeTime<R>(callback: (date: Date) => R): R;
+/** Laravel's freezeSecond(): freezeTime() at the start of the current second. */
+declare function freezeSecond(): Date;
+declare function freezeSecond<R>(callback: (date: Date) => R): R;
+/** Laravel's travel(5).minutes(): moves the clock on (a negative value moves it back) from where it stands. */
+declare function travel(value: number): Wormhole;
+/**
+ * Laravel's Wormhole: each unit moves the clock by `value` of it (months and years overflow as Carbon's do: 31 January
+ * plus a month is 3 March), in UTC. With a callback, it runs there, the clock travels back after it, and its result is
+ * returned. JavaScript dates hold milliseconds, so there are no microseconds.
+ */
+declare class Wormhole {
+    #private;
+    readonly value: number;
+    constructor(value: number);
+    millisecond(): void;
+    millisecond<R>(callback: () => R): R;
+    milliseconds(): void;
+    milliseconds<R>(callback: () => R): R;
+    second(): void;
+    second<R>(callback: () => R): R;
+    seconds(): void;
+    seconds<R>(callback: () => R): R;
+    minute(): void;
+    minute<R>(callback: () => R): R;
+    minutes(): void;
+    minutes<R>(callback: () => R): R;
+    hour(): void;
+    hour<R>(callback: () => R): R;
+    hours(): void;
+    hours<R>(callback: () => R): R;
+    day(): void;
+    day<R>(callback: () => R): R;
+    days(): void;
+    days<R>(callback: () => R): R;
+    week(): void;
+    week<R>(callback: () => R): R;
+    weeks(): void;
+    weeks<R>(callback: () => R): R;
+    month(): void;
+    month<R>(callback: () => R): R;
+    months(): void;
+    months<R>(callback: () => R): R;
+    year(): void;
+    year<R>(callback: () => R): R;
+    years(): void;
+    years<R>(callback: () => R): R;
+    /** Laravel's Wormhole::back(). */
+    static back(): Date;
+}
+
+/**
+ * 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, 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;
+    /** The request's session after the response. */
+    session?: Session;
+    /** 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;
+    /** 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;
+    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;
+    /**
+     * withSession() and flushSession() since the last started session: applied to the stored session (the one the
+     * session cookie points to) once the next request starts it, so they win over what it holds, as in Laravel.
+     */
+    sessionChanges: Array<(session: Session) => void>;
+    /** from(url): the session's previous URL for the next request only (Laravel sets it once). */
+    previousUrl: string | undefined;
+    /** Requests whose actingAs users reached the guards (the AuthFactory they went through). */
+    private readonly actingAsApplied;
+    constructor(app: Application);
+    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) => T | Promise<T>): Promise<T>;
+    /**
+     * Runs `run` in a request scope like this client's requests have (a request for `method uri` bound, the carried
+     * session, actingAs users), then carries the session and the users on, as after a request. Live.test() runs its
+     * mount and updates through it.
+     */
+    withinRequest<T>(run: () => Promise<T>, method?: string, uri?: string): 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, 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, context: ResponseContext): Promise<void>;
+    /**
+     * Laravel's actingAs() sets the user on the guard once, so a logout (or a login as someone else) in the
+     * request sticks. Reads each actingAs guard back and forgets or replaces its user to match.
+     */
+    protected syncActingAs(auth: AuthFactory): Promise<void>;
+    /** Applies the pending withSession()/flushSession() changes once the session has loaded what it stored. */
+    protected applyOnStart(session: Session): void;
+    /** Applies the pending withSession()/flushSession() changes to the session, once. */
+    protected applyPending(session: Session): void;
+    /** The request's (scoped) Session, created now so the carried attributes are in place before StartSession. */
+    protected scopeSession(scope: Container): Session | 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;
+    /**
+     * 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>;
+    /** Used by the default createApplication(). */
+    protected basePath(): string;
+    /** Used by the default createApplication(). */
+    protected providers(): Array<ServiceProvider | ServiceProviderClass>;
+    /** The variables applied (unless already set) before each application is created. */
+    protected environment(): Record<string, string>;
+    /** Adjust the fresh app before it boots, e.g. `app.make(ConfigRepository).set('mail.default', 'array')`. */
+    protected defineEnvironment(_app: Application): void | Promise<void>;
+    setUp(): Promise<void>;
+    tearDown(): Promise<void>;
+    /**
+     * Laravel's withoutVite(): in this test's requests vite([...]) and viteReactRefresh() render nothing, so feature
+     * tests of pages pass before `vite build` has written public/build/manifest.json.
+     */
+    withoutVite(): this;
+    /** 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;
+    /** Live.test() runs in this test's request scope (Live reads the same token: no import between the packages). */
+    setUp(): Promise<void>;
+    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, over what the stored session holds (Laravel's withSession()). */
+    withSession(data: Record<string, unknown>): this;
+    /** Empties the session, the stored one included, so the next request starts with none (Laravel's flushSession()). */
+    flushSession(): this;
+    /** Every following request is authenticated as `user` on `guard` (which also becomes the default guard). */
+    actingAs(user: Authenticatable, guard?: string): this;
+    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 InteractsWithTime: `t.travelTo(date)`, `t.travel(5).minutes()`, `t.freezeTime()`, `t.travelBack()`.
+ * The functions of the same names do the same outside a test case. A test case's tearDown travels back, so each of its
+ * tests ends in the real time; with the plain functions, call `travelBack()` in your own `afterEach()` or pass a callback.
+ */
+declare abstract class InteractsWithTime extends InteractsWithConsole {
+    travelTo(date: TravelDate): void;
+    travelTo<R>(date: TravelDate, callback: (date: Date) => R): R;
+    travel(value: number): Wormhole;
+    travelBack(): Date;
+    freezeTime(): Date;
+    freezeTime<R>(callback: (date: Date) => R): R;
+    freezeSecond(): Date;
+    freezeSecond<R>(callback: (date: Date) => R): R;
+    tearDown(): Promise<void>;
+}
+
+/**
+ * Laravel's TestCase. Extend it in tests/TestCase.ts (override createApplication() and set `static hooks`),
+ * then in each file: `const t = TestCase.boot()`, or `TestCase.boot({ uses: [RefreshDatabase] })`.
+ */
+declare abstract class TestCase extends InteractsWithTime {
+}
+
+/**
+ * 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, command: string, parameters?: Record<string, unknown>): Promise<void>;
+/** Laravel's usingInMemoryDatabase(): the default connection's database is ':memory:'. */
+declare function usingInMemoryDatabase(app: Application): boolean;
+/**
+ * Laravel's RefreshDatabase.
+ * - In-memory SQLite: every test's new application has an empty database, so it just runs `migrate`.
+ * - 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<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<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;
+/** A listener as assertListening() expects it: a class, a [class, method] pair, a closure, or Function for any closure. */
+type ExpectedListener = Listener<never> | readonly [Class<object>, string] | FunctionConstructor;
+/**
+ * Laravel's Event::fake(): records dispatched events instead of running listeners. With a list, only those
+ * events are faked and everything else reaches the original dispatcher (so model events keep working).
+ */
+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<E> | string | Array<Class<E> | string>, listener: Listener<E>): void;
+    hasListeners(event: Class<unknown> | string): boolean;
+    dispatch(event: object | string, payload?: unknown[]): Promise<unknown[]>;
+    /** Faked events return undefined (never false), so halting model events such as `saving` still proceed. */
+    until(event: object | string, payload?: unknown[]): Promise<unknown>;
+    subscribe(subscriber: Class<{
+        subscribe(events: EventDispatcher): void;
+    }>): void;
+    forget(event: Class<unknown> | string): void;
+    /** Dispatched at least once; a number asserts the exact count; a function filters (event, payload). */
+    assertDispatched<E>(event: Class<E> | string, callback?: CountOrFilter<[E, unknown[]]>): void;
+    assertDispatchedTimes<E>(event: Class<E> | string, times?: number): void;
+    assertNotDispatched<E>(event: Class<E> | string, callback?: EventFilter<E>): void;
+    assertNothingDispatched(): void;
+    /**
+     * Laravel's assertListening(event, listener): the original dispatcher has that listener for the event (a class, a
+     * [class, method] pair, the same closure, or Function for any closure; wildcard listeners count for a string event).
+     * With only the event, any listener will do.
+     */
+    assertListening(event: Class<unknown> | string, listener?: ExpectedListener): void;
+    /** The recorded events (objects, or names for string events) that match. */
+    dispatched<E>(event: Class<E> | string, callback?: EventFilter<E>): E[];
+    hasDispatched(event: Class<unknown> | string): boolean;
+    /** The original dispatcher's listeners for the event, as registered, wildcard ones included for a string event. */
+    private listenersFor;
+    private shouldFake;
+}
+
+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>;
+    /** Recorded as sent, never queued, like the real sendNow(). */
+    sendNow(mailable: Mailable): Promise<SentMessage | undefined>;
+    queue(mailable: Mailable): Promise<void>;
+    extend(_transport: string, _factory: (config: Record<string, unknown>) => MailTransport): void;
+    /** Sent (not queued) at least once; a number asserts the count; a filter gets (mailable, record). */
+    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 sendNowVia;
+    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<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;
+}
+/** By the extension as PHP's pathinfo() reads it: after the last dot of the base name ('.pdf' is a PDF, 'pdf' isn't). */
+declare function guessMimeType(path: string): string | undefined;
+/**
+ * An in-memory disk implementing the Filesystem contract, with Laravel's fake-disk assertions. (Laravel's fake
+ * 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, options?: PutOptions): Promise<string>;
+    /**
+     * The upload's own type, as the S3 disk sends it: its extension(), never the MIME type the client sent as such nor
+     * the stored name's type.
+     */
+    putFileAs(directory: string, file: UploadedFile, name: string, options?: PutOptions): Promise<string>;
+    private write;
+    delete(paths: string | string[]): Promise<boolean>;
+    copy(from: string, to: string): Promise<boolean>;
+    move(from: string, to: string): Promise<boolean>;
+    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, options?: PutOptions): Promise<string>;
+    putFileAs(directory: string, file: UploadedFile, name: string, options?: PutOptions): Promise<string>;
+    delete(paths: string | string[]): Promise<boolean>;
+    copy(from: string, to: string): Promise<boolean>;
+    move(from: string, to: string): Promise<boolean>;
+    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 typed by `mimeType` or the name's extension. Validation reads a file's bytes, so the
+     * file starts like its type (a PDF's `%PDF-`, a PNG's signature, text for text types) and passes `mimes` for its
+     * name, as Laravel's fakes do. It is at least its type's leading bytes and never empty, whatever the size asked for.
+     * An image made this way has no readable size: use image() for `dimensions`.
+     */
+    create(name: string, kilobytes?: number, mimeType?: string): File;
+    /**
+     * A real white image of the given size in the format the name's extension asks for: png, jpg/jpeg, gif, webp or
+     * bmp (any other name gets a JPEG, as Laravel's fakes do), so image, mimes and dimensions pass on it.
+     */
+    image(name: string, width?: number, height?: number): File;
+};
+
+/** Marks Live component classes (Symbol.for, so two copies of the package agree). */
+declare const COMPONENT: unique symbol;
+/** 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;
+    private readonly messages;
+    constructor(messages: Record<string, string[]>);
+    /** Adds to the component's errors, as addError() does. */
+    add(key: string, message: string): void;
+    has(key: string): boolean;
+    first(key?: string): string | undefined;
+    get(key: string): string[];
+    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;
+    /**
+     * Livewire's #[Lazy]: every embed (and the full page) renders the placeholder first and mounts once the browser shows
+     * it. `<Live component={…} lazy={false} />` mounts one at once. The placeholder is the component's
+     * `placeholder(params)` method (TSX), else the `live.lazy_placeholder` view, else an empty `<div>`: give it the root
+     * element the component renders.
+     */
+    static lazy?: boolean;
+    /** Static fallbacks for runtimes without decorators: { event: 'method' }, locked names, computed getter names. */
+    static listeners?: Record<string, string>;
+    static locked?: string[];
+    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;
+    /**
+     * redirect() to a named route: `this.redirectRoute('posts.show', post, { navigate: true })`. Once `oriel
+     * route:types` has run, the name and the route's parameters are checked, as route()'s are.
+     */
+    redirectRoute<N extends RouteName>(name: N, ...args: RouteArguments<N, [options?: {
+        navigate?: boolean;
+    }]>): void;
+    /**
+     * Validates the public state. On success clears the error bag and returns the validated data, typed from the rules
+     * (`await this.validate({ title: 'required|string' })` is `{ title: string }`); on failure fills the error bag and
+     * throws (the rest of the action is skipped and the component re-renders with `errors`).
+     */
+    validate<const R extends Rules>(rules: R, messages?: Record<string, string>, attributes?: Record<string, string>): Promise<InferValidatedType<R>>;
+    addError(key: string, message: string): void;
+    /** Clears every error, or only those of `keys`. */
+    resetErrorBag(...keys: string[]): void;
+    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;
+    /**
+     * An action for an `o:` directive, typed against its method: `o:click={this.$action(this.delete, tag.id)}` writes
+     * `delete(5)`, and a string where `delete` takes a number is a type error. The arguments are written as JSON, the
+     * trailing `undefined` ones left out so the method's defaults apply. The method must be one of this component's
+     * actions (a public method of its class, not a hook and not @Locked); anything else throws while rendering.
+     */
+    $action<P extends unknown[]>(method: (...params: P) => unknown, ...params: NoInfer<P>): string;
+    /** A full-page component as a route action: Route.get('/counter', Counter). Route parameters go to mount(). */
+    __invoke(): Promise<unknown>;
+}
+
+/** @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;
+
+/**
+ * Runs Live.test()'s mount and each update. The testing package binds one for every test, so they run in a request
+ * scope like the test's HTTP requests (a request, the carried session, actingAs users) and what they change carries
+ * on to the next request. Without one they run in the current scope.
+ */
+type TestRequestScope = <T>(run: () => Promise<T>) => Promise<T>;
+declare const TestRequestScope: Token<TestRequestScope>;
+/**
+ * Livewire's Livewire::test(): drives one component through the real mount → snapshot → checksum → update pipeline
+ * (no HTTP), inside the test's request scope. 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 readonly scope;
+    private constructor();
+    /**
+     * Mounts `component` with `params`, as `<Live component={…} {...params} />` would. A lazy component mounts at once
+     * (Livewire's withoutLazyLoading()); `{ lazy: true }` renders its placeholder, and `call('__lazyLoad', …)` loads it.
+     */
+    static create<C extends Component>(component: Class<C> | string, params?: Record<string, unknown>): Promise<Testable<C>>;
+    /** The component instance after the last request. */
+    instance(): C;
+    /** 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;
+    /**
+     * Sets public properties through an update. A file (a FakeFile) or an array of files is uploaded as `o:model` on a
+     * file input does it: the upload rules, the temporary disk, then a TemporaryUploadedFile (or an array) in the
+     * property, or the upload's errors on it (Livewire's).
+     */
+    set(path: string | Record<string, unknown>, value?: unknown): Promise<this>;
+    /** Uploads `files` into the property `name` (an array when `multiple`), as the browser's upload calls do. */
+    upload(name: string, files: readonly Blob[], multiple?: boolean): Promise<this>;
+    call(method: string, ...params: unknown[]): Promise<this>;
+    toggle(path: string): Promise<this>;
+    /** Dispatches an event to this component, as the browser does for its listeners. */
+    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;
+    /** Each value, HTML-escaped, appears in the rendered text: the HTML with its tags stripped (Livewire's assertSeeText). */
+    assertSeeText(...values: string[]): this;
+    assertDontSeeText(...values: string[]): this;
+    assertDispatched(name: string, params?: Record<string, unknown>): this;
+    assertNotDispatched(name: string): this;
+    /** The error bag has errors for every key given (or any error at all with no keys). */
+    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;
+    /**
+     * Renders the placeholder and mounts the component once it scrolls into view (`'on-load'`: once the page starts);
+     * `false` mounts a `static lazy` component at once.
+     */
+    lazy?: boolean | 'on-load';
+    [param: string]: unknown;
+}
+/** Blade's @livewire('counter', ['count' => 3], key('c1')): the component's first render, as trusted HTML. */
+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>;
+    /**
+     * Mounts a component: boot(), the params into its properties, mount(params), then its first render. A lazy one
+     * (`lazy` in the params, or `static lazy`) renders its placeholder instead and mounts when the browser loads it.
+     */
+    mountComponent(component: string | Class<unknown>, embedParams?: Record<string, unknown>, existing?: Component): Promise<ComponentResult>;
+    /**
+     * A lazy component's first render (Livewire's): its placeholder, with the state it has before mount() and the mount
+     * params signed for the `__lazyLoad` call the browser makes when it shows it (`o:lazy`, or `o:lazy-on-load`).
+     */
+    private mountPlaceholder;
+    /** Applies each component's updates and calls, re-renders it and returns its new snapshot and effects. */
+    update(request: LiveUpdateRequest): Promise<LiveUpdateResponse>;
+    updateComponent(snapshotJson: string, updates: Record<string, unknown>, calls: Call[]): Promise<ComponentResult>;
+    /**
+     * The mount params and placeholder tag of a `__lazyLoad` request, or undefined for any other update. The load comes
+     * alone (no updates, no other call: the browser sends it in a request of its own) and its payload must be the one
+     * signed for this component: anything else is refused as corrupt (a 403) before the component boots.
+     */
+    private lazyLoad;
+    /**
+     * The route action of POST /oriel/live/update. Each component's update runs behind the persistent middleware of the
+     * route that rendered its page (Livewire's): `auth`, `verified`, `guest` and `can`, with the page route's parameters
+     * bound again. A signed-out tab gets a 401, a revoked ability a 403 and a deleted model a 404, before the component
+     * hydrates. When a middleware answers instead (a redirect), that is the response. A key first flashed during the
+     * update shows in this response only, unless the update redirects.
+     */
+    handle(request: HttpRequest): Promise<LiveUpdateResponse | Response>;
+    /** A full-page component (Route.get('/counter', Counter)): mounted with the route parameters, inside the layout. */
+    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, an upload call, or a public method. Returns its return value. */
+    private call;
+    /**
+     * Renders the component (rendering/rendered hooks, nested children tracked) and checks for a single root. A
+     * WithPagination component's page and page URL are what paginate() reads while it renders, as in its mount() and in
+     * its update's hooks and actions.
+     */
+    private render;
+    /** The absolute URL of the page a memo path belongs to, on the current request's origin ('/' + path without one). */
+    private pageUrl;
+    /** Dispatches, redirects: the effects every response carries. */
+    private effects;
+    /** dehydrate() hook, then the state as snapshot data, the error bag, and the checksum over both. */
+    private snapshot;
+}
+
+/** The URI the client runtime posts updates to. */
+declare const UPDATE_URI = "/oriel/live/update";
+/**
+ * Binds the LiveManager and the PaginationState that WithPagination components answer, merges the `live` config,
+ * registers POST /oriel/live/update (named `live.update`, in the `web` group: sessions and CSRF apply), the upload and
+ * preview routes of WithFileUploads (`live.upload-file`, `live.preview-file`), the make:live command, and the
+ * components under app/Live.
+ */
+declare class LiveServiceProvider extends ServiceProvider$1 {
+    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;
+}
+/** An upload or preview URL whose signature is missing, wrong or expired (Livewire's 401). Nothing is read or stored. */
+declare class InvalidUploadSignatureError extends LiveError {
+    readonly name: string;
+    readonly kind: ErrorKind;
+    readonly status: number;
+    constructor();
+}
+/** A preview of a temporary upload that is no longer on the disk (cleaned up, or stored and deleted). */
+declare class TemporaryFileNotFoundError extends LiveError {
+    readonly name: string;
+    readonly kind: ErrorKind;
+    readonly status: number;
+    constructor(filename: string);
+}
+/** temporaryUrl() on an upload whose type has no preview (live.temporary_file_upload.preview_mimes). */
+declare class FileNotPreviewableError extends LiveError {
+    readonly name: string;
+    constructor(extension: string);
+}
+/** The errors an upload came back with (`_uploadErrored`): the component re-renders with them on the property. */
+declare class UploadValidationError extends LiveError {
+    readonly errors: Record<string, string[]>;
+    readonly name: string;
+    readonly kind: ErrorKind;
+    readonly status: number;
+    readonly errorBag: string;
+    constructor(errors: Record<string, string[]>);
+}
+
+/**
+ * Livewire's `temporary_file_upload` settings, read from config `live.temporary_file_upload.*` (each one falls back on
+ * its own): the disk (the default filesystem disk), the directory on it, the rules every upload must pass, the upload
+ * route's middleware, the types a preview is served for, how long an upload URL lasts (minutes), and whether a finished
+ * upload removes the temporary files older than a day.
+ */
+declare const TEMPORARY_UPLOAD_DEFAULTS: {
+    disk: string | null;
+    directory: string;
+    rules: string | string[];
+    middleware: string | string[];
+    preview_mimes: string[];
+    max_upload_time: number;
+    cleanup: boolean;
+};
+/** What a temporary upload is: its stored name on the temporary disk and what the browser sent (signed with it). */
+interface TemporaryFileData {
+    /** A random 40-character name with the extension its bytes showed: `live-tmp/<filename>` on the temporary disk. */
+    filename: string;
+    /** The name the browser gave the file. */
+    name: string;
+    size: number;
+    /** The MIME type the browser claimed. */
+    type: string;
+    /** The extension of the upload's own type (its bytes, else a plain claimed extension), or ''. */
+    extension: string;
+}
+/**
+ * Livewire's TemporaryUploadedFile: a file the browser uploaded to the temporary directory before an action stores
+ * it. A WithFileUploads component's property holds one (or an array of them) once `o:model` on a file input has
+ * uploaded it: validate it like any upload (`'photo' => 'image|max:1024'`), preview it with `temporaryUrl()`, then
+ * `store()` it. It travels in the component's snapshot as its data, signed with the rest.
+ */
+declare class TemporaryUploadedFile implements UploadedFile {
+    #private;
+    readonly filename: string;
+    readonly clientName: string;
+    readonly mimeType: string;
+    readonly size: number;
+    constructor(data: TemporaryFileData);
+    /** What the snapshot carries. */
+    toData(): TemporaryFileData;
+    /** The file's path on the temporary disk. */
+    get path(): string;
+    /** The extension of the upload's own type, as FormUploadedFile's extension(): what putFile() names a stored copy by. */
+    extension(): string;
+    /** The extension of the name the browser gave the file, lower-cased ('' without one). */
+    clientExtension(): string;
+    /** A random 40-character name with extension(), as FormUploadedFile's. */
+    hashName(): string;
+    arrayBuffer(): Promise<ArrayBuffer>;
+    text(): Promise<string>;
+    /** The file's bytes from the temporary disk, opened on the first read. */
+    stream(): ReadableStream<Uint8Array>;
+    /** Stores a copy under a random name in `directory`, on `disk` (by default the temporary disk, as Livewire's). */
+    store(directory: string, disk?: string): Promise<string>;
+    storeAs(directory: string, name: string, disk?: string): Promise<string>;
+    exists(): Promise<boolean>;
+    /** Removes the temporary file (a stored copy stays). */
+    delete(): Promise<boolean>;
+    /** Whether temporaryUrl() serves this file: its type is in `live.temporary_file_upload.preview_mimes`. */
+    isPreviewable(): boolean;
+    /**
+     * A signed link to the file for `<img src>` or `<video src>` before it is stored. It lasts until the end of the hour
+     * at least 30 minutes away (Livewire's), so a re-render keeps the same link and the browser doesn't reload it.
+     */
+    temporaryUrl(): string;
+}
+
+/** Where the browser POSTs a WithFileUploads component's files (Livewire's /livewire/upload-file), named live.upload-file. */
+declare const UPLOAD_URI = "/oriel/live/upload-file";
+/** Where temporaryUrl() links lead (Livewire's /livewire/preview-file/{filename}), named live.preview-file. */
+declare const PREVIEW_URI = "/oriel/live/preview-file";
+
+/** The route middleware an update re-applies by default (config live.persistent_middleware), by alias. */
+declare const PERSISTENT_MIDDLEWARE: string[];
+/** A route middleware after alias and group expansion: 'auth:web' → { cls: Authenticate, parameters: ['web'] }. */
+interface PersistentMiddleware {
+    readonly cls: MiddlewareClass;
+    readonly parameters: readonly string[];
+}
+/**
+ * Livewire's persistent middleware: the middleware among `persistent` (aliases) that the page route (the component's
+ * memo path and method) ran, in the order an update runs them. A path no route matches has none.
+ */
+declare function persistentMiddleware(router: Router, persistent: readonly string[], method: string, path: string): PersistentMiddleware[];
+
+type ComponentConstructor = abstract new (...args: any[]) => Component;
+/** What WithPagination() adds to a component: its page and the actions that move it. */
+interface Paginated {
+    /** The current page. The browser may set it; Live reads it as a page number. */
+    page: number;
+    nextPage(): Promise<void>;
+    previousPage(): Promise<void>;
+    gotoPage(page: number | string): Promise<void>;
+    resetPage(): Promise<void>;
+    setPage(page: number | string): Promise<void>;
+}
+/**
+ * Livewire's WithPagination: `class Posts extends WithPagination(Component)`. The public `page` (1 to start; there
+ * is no address-bar sync) is what `paginate()` shows in the component (in `render()`, `mount()`, `hydrate()`, the
+ * update hooks and actions, or in a `@Computed` getter any of them reads), and its page links are built on the
+ * page's URL. The actions move it: `o:click="nextPage"`, `previousPage`, `gotoPage(3)`, `setPage(3)`,
+ * `resetPage` (call it from `updatedSearch()` so a new search starts on page 1). `updatingPage(page)` and
+ * `updatedPage(page)` run around every change. One paginator per component: other page names read the request.
+ */
+declare function WithPagination<TBase extends ComponentConstructor>(Base: TBase): TBase & (abstract new (...args: any[]) => Paginated);
+
+/**
+ * Livewire's WithFileUploads: `class Profile extends WithFileUploads(Component)`. A file input with `o:model="photo"`
+ * uploads the file to the temporary directory as soon as it is picked, then sets `photo` to a TemporaryUploadedFile
+ * (`<input type="file" multiple>` sets an array), through `updatingPhoto()`/`updatedPhoto()` like any update. Validate
+ * it with the file rules, preview it with `temporaryUrl()`, store it with `store()`.
+ */
+declare function WithFileUploads<TBase extends ComponentConstructor>(Base: TBase): TBase;
+
+/**
+ * What <Pagination> reads from a paginator. Structural, since Live can't import Database: paginate()'s
+ * LengthAwarePaginator (with lastPage(), so page buttons) and simplePaginate()'s Paginator (Previous and Next only).
+ */
+interface PaginationSource {
+    currentPage(): number;
+    lastPage?(): number;
+    hasMorePages(): boolean;
+    onFirstPage(): boolean;
+    /** Page buttons on each side of the current one (the paginator's onEachSide(), 3 by default). */
+    readonly onEachSideCount?: number;
+    /** Not cursorPaginate(): its pages are cursors, which a component's page number can't follow. */
+    readonly nextCursor?: never;
+}
+interface PaginationProps {
+    paginator: PaginationSource;
+    /** Classes for the <nav>, such as its layout ("flex gap-2"); in your file, so Tailwind generates them. */
+    class?: string;
+}
+/**
+ * Livewire's pagination links for a WithPagination component: `<Pagination paginator={posts} />` in render(). A
+ * <nav aria-label="Pagination"> with « Previous, the page buttons and Next » as Live actions (previousPage,
+ * gotoPage(n), nextPage), the current page marked aria-current="page", the ends disabled, the kits' theme classes
+ * (btn, btn-secondary). Nothing when everything fits on one page. The address bar is left alone.
+ */
+declare function Pagination({ paginator, class: className }: PaginationProps): Htmlable;
+
+export { type DatabaseTestOptions as $, UploadValidationError as A, BusFake as B, Component as C, WithPagination as D, EventFake as E, FileNotPreviewableError as F, componentName as G, live as H, InvalidLiveRequestError as I, persistentMiddleware as J, AnonymousNotifiable as K, Live as L, MailFake as M, NotificationFake as N, On as O, PERSISTENT_MIDDLEWARE as P, QueueFake as Q, AssertableInertia as R, StorageFake as S, TEMPORARY_UPLOAD_DEFAULTS as T, UPDATE_URI as U, AssertableJson as V, WithFileUploads as W, type BatchRecord as X, type BootOptions as Y, type CountOrFilter as Z, DatabaseMigrations as _, type ComponentResult as a, DatabaseTransactions as a0, type DispatchedEvent as a1, type ExpectedErrors as a2, type ExpectedListener as a3, FakeDisk as a4, FakeFile as a5, HttpClient as a6, InteractsWithApplication as a7, InteractsWithConsole as a8, InteractsWithDatabase as a9, cookiePrefix as aA, decryptCookie as aB, encryptCookie as aC, flatten as aD, freezeSecond as aE, freezeTime as aF, guessMimeType as aG, inertiaPageOf as aH, install as aI, isExpired as aJ, matches as aK, nameOf as aL, recordingExceptionHandler as aM, recordingViewFactory as aN, responseCookies as aO, runCommand as aP, travel as aQ, travelBack as aR, travelTo as aS, usingInMemoryDatabase as aT, InteractsWithTime as aa, type JsonStructure as ab, MailRecord as ac, MakesHttpRequests as ad, PendingCommand as ae, type PushedJob as af, RefreshDatabase as ag, RefreshDatabaseState as ah, type RequestData as ai, type RequestOptions as aj, type ResponseContext as ak, type ResponseCookie as al, type SentNotification as am, TESTING_ENVIRONMENT as an, type TableOrModel as ao, type Target as ap, TestCase as aq, type TestHooks as ar, TestResponse as as, type TestTrait as at, type TravelDate as au, Wormhole as av, actingAsAuthFactory as aw, addresses as ax, applyEnvironment as ay, cookieHeader as az, Computed as b, CorruptComponentPayloadError as c, ErrorBag as d, InvalidUploadSignatureError as e, LiveComponentManager as f, LiveComponentNotFoundError as g, LiveError as h, type LiveProps as i, LiveServiceProvider as j, Locked as k, MethodNotCallableError as l, PREVIEW_URI as m, type Paginated as n, Pagination as o, type PaginationProps as p, type PaginationSource as q, PendingEvent as r, type PersistentMiddleware as s, PropertyNotUpdatableError as t, type TemporaryFileData as u, TemporaryFileNotFoundError as v, TemporaryUploadedFile as w, TestRequestScope as x, Testable as y, UPLOAD_URI as z };