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

package/dist/index.d.ts

@@ -1,8 +1,8 @@
 import { C as ClassRegistry$3, a as Class$j, S as ServiceProvider$u, A as Application$c, b as Abstract$j, c as ConfigRepository$3 } from './index.d-DOlTeG-8.js';
-import { Token as Token$j, ServiceProviderClass as ServiceProviderClass$a } from './contracts.js';
+import { Token as Token$j, ServiceProviderClass as ServiceProviderClass$a, Notification as Notification$4 } from './contracts.js';
 export { InertiaPage, RouteList, RouteName } from './contracts.js';
-import { T as Target, B as BusFake, E as EventFake, M as MailFake, N as NotificationFake, Q as QueueFake, F as FakeDisk } from './testing-D3dCOkTm.js';
-export { C as Component, a as ComponentResult, b as Computed, c as CorruptComponentPayloadError, d as ErrorBag, I as InvalidLiveRequestError, L as Live, e as LiveComponentManager, f as LiveComponentNotFoundError, g as LiveError, h as LiveProps, i as LiveServiceProvider, j as Locked, k as MethodNotCallableError, O as On, P as PERSISTENT_MIDDLEWARE, l as PendingEvent, m as PersistentMiddleware, n as PropertyNotUpdatableError, o as TestRequestScope, p as Testable, U as UPDATE_URI, q as componentName, r as live, s as persistentMiddleware } from './testing-D3dCOkTm.js';
+import { T as Target, B as BusFake, E as EventFake, M as MailFake, N as NotificationFake, Q as QueueFake, F as FakeDisk } from './testing-BErengYY.js';
+export { C as Component, a as ComponentResult, b as Computed, c as CorruptComponentPayloadError, d as ErrorBag, I as InvalidLiveRequestError, L as Live, e as LiveComponentManager, f as LiveComponentNotFoundError, g as LiveError, h as LiveProps, i as LiveServiceProvider, j as Locked, k as MethodNotCallableError, O as On, P as PERSISTENT_MIDDLEWARE, l as Paginated, m as Pagination, n as PaginationProps, o as PaginationSource, p as PendingEvent, q as PersistentMiddleware, r as PropertyNotUpdatableError, s as TestRequestScope, t as Testable, U as UPDATE_URI, W as WithPagination, u as componentName, v as live, w as persistentMiddleware } from './testing-BErengYY.js';
 import { IncomingMessage, ServerResponse } from 'node:http';
 import { Kysely, RawBuilder, CompiledQuery, QueryResult, SqliteDatabase, SqliteStatement, Dialect } from 'kysely';
 import Redis$1, { Redis } from 'ioredis';
@@ -679,7 +679,7 @@ declare class ApplicationBuilder {
 type LifecycleCallback = (app: Application$b) => void | Promise<void>;
 declare class Application$a extends Container$h implements Application$b {
     private readonly base;
-    readonly version = "0.1.0-alpha.4";
+    readonly version = "0.1.0-alpha.5";
     private readonly providers;
     private readonly bootingCallbacks;
     private readonly bootedCallbacks;
@@ -877,6 +877,11 @@ interface OrielError$i extends Error {
 
 /** Options a job class may declare as public fields. Their presence (or implementing ShouldQueue) makes things queueable. */
 interface ShouldQueue$5 {
+    /**
+     * Marks the class as queued at run time: `implements ShouldQueue` leaves no trace once compiled, so the interface
+     * asks for `readonly shouldQueue = true`. Jobs, listeners, mailables and notifications carrying it are queued.
+     */
+    readonly shouldQueue: true;
     connection?: string;
     queue?: string;
     /** Seconds. */
@@ -1055,18 +1060,11 @@ declare class MailNotificationChannel implements NotificationChannel {
 }
 
 declare const NOTIFICATIONS_TABLE = "notifications";
-interface DatabaseNotificationRecord {
-    readonly id: string;
-    readonly type: string;
-    readonly data: Record<string, unknown>;
-    readonly createdAt: Date;
-    readonly updatedAt: Date;
-    readAt: Date | undefined;
-    markAsRead(): Promise<void>;
-    markAsUnread(): Promise<void>;
-}
-/** notifiable_type + notifiable_id together, never id alone. */
-declare function fetchNotifications(notifiableType: string, notifiableId: unknown, filter?: 'all' | 'read' | 'unread'): Promise<DatabaseNotificationRecord[]>;
+/**
+ * Laravel's DatabaseChannel: one row in `notifications` per notifiable, with what toDatabase() (or toArray())
+ * returns as JSON. The row is keyed as `user.notifications()` reads it: `notifiable_type` is the model's morph class
+ * (its morph map alias, else its class name) and it goes to the model's own connection.
+ */
 declare class DatabaseNotificationChannel implements NotificationChannel {
     send(notifiable: Notifiable$2, notification: Notification$3): Promise<void>;
 }
@@ -1142,19 +1140,17 @@ declare class SendQueuedNotifications implements Job$5 {
 
 type NotifiableConstructor = new (...args: any[]) => object;
 /**
- * Mirrors Laravel's Illuminate\Notifications\Notifiable trait: `class User extends Notifiable(Model) {}`. Custom
- * routing per channel follows Laravel's own resolution order: a `routeNotificationFor<Channel>()` method (Studly
- * name) wins if present, else 'mail' reads `email`/`getAttribute('email')`, 'database' returns the instance itself
- * (the database channel derives the table row from it directly), and anything else is unrouted (`undefined`).
+ * Laravel's RoutesNotifications trait: `notify()`, `notifyNow()` and `routeNotificationFor()`. Apps use
+ * `Notifiable` from '@orieljs/framework', which adds the database notifications relations. Custom routing per
+ * channel follows Laravel's order: a `routeNotificationFor<Channel>()` method (Studly name) wins if present, else
+ * 'mail' reads `email`/`getAttribute('email')`, 'database' returns the instance itself (the database channel derives
+ * the row from it), and anything else is unrouted (`undefined`).
  */
-declare function Notifiable$1<TBase extends NotifiableConstructor>(Base: TBase): {
+declare function RoutesNotifications<TBase extends NotifiableConstructor>(Base: TBase): {
     new (...args: any[]): {
         routeNotificationFor(channel: string, notification: Notification$3): unknown;
         notify(notification: Notification$3): Promise<void>;
         notifyNow(notification: Notification$3, channels?: string[]): Promise<void>;
-        notifications(): Promise<DatabaseNotificationRecord[]>;
-        unreadNotifications(): Promise<DatabaseNotificationRecord[]>;
-        readNotifications(): Promise<DatabaseNotificationRecord[]>;
     };
 } & TBase;
 
@@ -1798,6 +1794,12 @@ declare class BaseRouter implements Router$1 {
     getPatternVersion(): number;
     getBinder(parameter: string): RouteBinder | undefined;
     getModel(parameter: string): Class$e<unknown> | undefined;
+    /**
+     * Binds a matched route's raw parameter values as a request to it would: Route.bind() callbacks, Route.model(),
+     * then implicit binding through the RouteModelResolver of `container`. A missing model throws
+     * RouteModelNotFoundError (404). Live uses it to check a page route's `can:` middleware again on each update.
+     */
+    substituteBindings(route: RouteDefinition, values: Readonly<Record<string, string | undefined>>, container: Container$e): Promise<Record<string, unknown>>;
     aliasMiddleware(name: string, middleware: MiddlewareClass$1): this;
     /** The middleware aliases (Laravel's Router::getMiddleware()). */
     getMiddleware(): Record<string, MiddlewareClass$1>;
@@ -2008,6 +2010,29 @@ declare function toResponse(request: unknown, value: unknown): Promise<Response>
  */
 declare const Route$1: Facade$a<BaseRouter, object>;
 
+/**
+ * Dispatched by the health route (`/up`) on every request (Laravel's DiagnosingHealth event). A listener checks
+ * something the application needs, such as the database or the cache, and throws when it fails: `/up` then answers
+ * 500 with "Application experiencing problems", and the exception is reported.
+ *
+ *   Event.listen(DiagnosingHealth, async () => { await DB.select('select 1') })
+ */
+declare class DiagnosingHealth {
+}
+interface HealthPage {
+    /** False when a check failed: the page says so and the status is 500 (default true). */
+    healthy?: boolean;
+    /** How long the request took, shown when given. */
+    milliseconds?: number;
+    /** The page title (default "Oriel"). */
+    appName?: string;
+}
+/**
+ * The health route's page (Laravel's health-up view): "Application up", or "Application experiencing problems" with
+ * status 500. Self-contained HTML with inline CSS: it loads nothing, so it answers even when the assets don't.
+ */
+declare function healthResponse(page?: HealthPage): Response;
+
 /** A route file may export a function instead of (or as well as) calling the Route facade at the top level. */
 type RouteFileCallback = (router: Router$1) => void | Promise<void>;
 /**
@@ -2016,13 +2041,12 @@ type RouteFileCallback = (router: Router$1) => void | Promise<void>;
  * A default export that is a function is called with the router.
  */
 declare function loadRoutesFrom(app: Application$7, router: Router$1, file: string): Promise<void>;
-/** The health route's page (Laravel's `/up`): 200 as long as the application boots and handles requests. */
-declare function healthResponse(): Response;
 
 /**
  * Binds the Router and the UrlGenerator, registers the `signed` and `throttle` middleware, and once the app has booted
- * loads the files given to withRouting(): the health URI, then the web files in the `web` middleware group, then the
- * api files under the api prefix in the `api` group (Laravel's ApplicationBuilder::withRouting).
+ * loads the files given to withRouting(): the health URI (which dispatches DiagnosingHealth), then the web files in the
+ * `web` middleware group, then the api files under the api prefix in the `api` group (Laravel's
+ * ApplicationBuilder::withRouting).
  */
 declare class RoutingServiceProvider extends ServiceProvider$o {
     #private;
@@ -2494,6 +2518,63 @@ declare abstract class ServiceProvider$m implements ServiceProvider$u {
     protected mergeConfigFrom(defaults: Record<string, unknown>, key: string): void;
 }
 
+/**
+ * What a file's bytes show it to be, read from its leading bytes the way PHP's finfo reads them for Laravel (the file
+ * validation rules, and the extension a stored upload gets). The client's file name and MIME type are never consulted.
+ */
+interface DetectedType {
+    /** 'image/png', 'text/plain', …; 'application/octet-stream' when no format matches, 'application/x-empty' for no bytes. */
+    readonly mime: string;
+    /** The extensions that name the type, the usual one first. Empty when the bytes match no format. */
+    readonly extensions: readonly string[];
+}
+declare const JPEG: DetectedType;
+declare const PNG: DetectedType;
+declare const GIF: DetectedType;
+declare const WEBP: DetectedType;
+declare const AVIF: DetectedType;
+declare const BMP: DetectedType;
+declare const SVG: DetectedType;
+declare const PDF: DetectedType;
+declare const HTML: DetectedType;
+declare const XML: DetectedType;
+declare const TEXT: DetectedType;
+declare const UNKNOWN: DetectedType;
+declare const EMPTY: DetectedType;
+/** The raster formats the image rule accepts: Laravel 12's jpg, jpeg, png, gif, bmp and webp, plus AVIF. */
+declare const RASTER_IMAGES: ReadonlySet<string>;
+/** Every format recognised by its bytes other than plain text. */
+declare const BINARY_AND_MARKUP_TYPES: readonly DetectedType[];
+/**
+ * How much of a file is read to tell its type: the window checked for binary bytes (libmagic reads its first megabyte
+ * too). Uploads read this much to be named, so naming and validation see the same bytes.
+ */
+declare const SNIFF_BYTES: number;
+/** The type the bytes show. */
+declare function detectFileType(bytes: Uint8Array): DetectedType;
+
+declare const fileType_AVIF: typeof AVIF;
+declare const fileType_BINARY_AND_MARKUP_TYPES: typeof BINARY_AND_MARKUP_TYPES;
+declare const fileType_BMP: typeof BMP;
+type fileType_DetectedType = DetectedType;
+declare const fileType_EMPTY: typeof EMPTY;
+declare const fileType_GIF: typeof GIF;
+declare const fileType_HTML: typeof HTML;
+declare const fileType_JPEG: typeof JPEG;
+declare const fileType_PDF: typeof PDF;
+declare const fileType_PNG: typeof PNG;
+declare const fileType_RASTER_IMAGES: typeof RASTER_IMAGES;
+declare const fileType_SNIFF_BYTES: typeof SNIFF_BYTES;
+declare const fileType_SVG: typeof SVG;
+declare const fileType_TEXT: typeof TEXT;
+declare const fileType_UNKNOWN: typeof UNKNOWN;
+declare const fileType_WEBP: typeof WEBP;
+declare const fileType_XML: typeof XML;
+declare const fileType_detectFileType: typeof detectFileType;
+declare namespace fileType {
+  export { fileType_AVIF as AVIF, fileType_BINARY_AND_MARKUP_TYPES as BINARY_AND_MARKUP_TYPES, fileType_BMP as BMP, type fileType_DetectedType as DetectedType, fileType_EMPTY as EMPTY, fileType_GIF as GIF, fileType_HTML as HTML, fileType_JPEG as JPEG, fileType_PDF as PDF, fileType_PNG as PNG, fileType_RASTER_IMAGES as RASTER_IMAGES, fileType_SNIFF_BYTES as SNIFF_BYTES, fileType_SVG as SVG, fileType_TEXT as TEXT, fileType_UNKNOWN as UNKNOWN, fileType_WEBP as WEBP, fileType_XML as XML, fileType_detectFileType as detectFileType };
+}
+
 /**
  * Whether a JSON text nests objects and arrays deeper than `maxDepth`, found by scanning (no parsing, no recursion):
  * brackets inside strings don't count. The kernel answers 400 for such bodies (http.max_json_depth) before the
@@ -2557,13 +2638,26 @@ declare function clientAddress(request: Request): string | undefined;
 /** An uploaded file from a multipart body. store()/storeAs() go through the FilesystemManager. */
 declare class FormUploadedFile implements UploadedFile$5 {
     private readonly file;
+    private readonly detected?;
     readonly clientName: string;
     readonly mimeType: string;
     readonly size: number;
+    /**
+     * Reads the leading bytes first, so extension(), hashName() and store() name the file by its content. The request
+     * builds its uploads this way.
+     */
+    static fromFile(file: Blob & {
+        readonly name?: string;
+    }): Promise<FormUploadedFile>;
     constructor(file: Blob & {
         readonly name?: string;
-    });
-    /** Guessed from the MIME type, falling back to the client's extension (Laravel's extension()). */
+    }, detected?: fileType.DetectedType | undefined);
+    /**
+     * Laravel's extension(): the type the bytes show (guessExtension()), when they were read and match a known format.
+     * Text and bytes no format matches keep the client's claim (its MIME type, else its file name) when it is a plain
+     * extension, unless it names a format the bytes would have shown or one a browser renders or runs: otherwise 'txt'
+     * for text, '' for the rest. Unread (built directly), the client's claim when it is a plain extension, else ''.
+     */
     extension(): string;
     clientExtension(): string;
     /** A random 40-character name with the guessed extension. */
@@ -3101,6 +3195,11 @@ interface OrielError$e extends Error {
 
 /** Options a job class may declare as public fields. Their presence (or implementing ShouldQueue) makes things queueable. */
 interface ShouldQueue$4 {
+    /**
+     * Marks the class as queued at run time: `implements ShouldQueue` leaves no trace once compiled, so the interface
+     * asks for `readonly shouldQueue = true`. Jobs, listeners, mailables and notifications carrying it are queued.
+     */
+    readonly shouldQueue: true;
     connection?: string;
     queue?: string;
     /** Seconds. */
@@ -3956,6 +4055,8 @@ interface ModelInstance$2 {
     getTable(): string;
     getRouteKey(): unknown;
     getRouteKeyName(): string;
+    /** The value stored in a polymorphic `*_type` column for this model: its morph map alias, else its class name. */
+    getMorphClass(): string;
     getAttribute<T = unknown>(key: string): T;
     setAttribute(key: string, value: unknown): this;
     fill(attributes: Row$4): this;
@@ -4008,6 +4109,28 @@ interface ConsoleKernel$3 {
     command(signature: string, handler: (this: CommandContext$3, ...args: unknown[]) => number | void | Promise<number | void>): ClosureCommand$3;
 }
 declare const ConsoleKernel$3: Token$j<ConsoleKernel$3>;
+/**
+ * A stored database notification (Laravel's DatabaseNotification model): one row of the `notifications` table, with
+ * its snake_case columns. `user.notifications()`, `unreadNotifications()` and `readNotifications()` query these,
+ * newest first.
+ */
+interface DatabaseNotification$1 extends ModelInstance$2 {
+    /** A UUID. */
+    readonly id: string;
+    /** The notification's class name. */
+    readonly type: string;
+    /** What the notification's toDatabase() (or toArray()) returned. */
+    readonly data: Record<string, unknown>;
+    read_at: Date | null;
+    readonly created_at: Date | null;
+    readonly updated_at: Date | null;
+    /** Sets read_at to now and saves, unless it is already read. */
+    markAsRead(): Promise<void>;
+    /** Clears read_at and saves, unless it is already unread. */
+    markAsUnread(): Promise<void>;
+    read(): boolean;
+    unread(): boolean;
+}
 
 type Operator$4 = '=' | '==' | '===' | '!=' | '!==' | '<>' | '<' | '<=' | '>' | '>=';
 
@@ -4773,7 +4896,10 @@ declare class LengthAwarePaginator<T> extends AbstractPaginator<T> {
     hasMorePages(): boolean;
     onLastPage(): boolean;
     nextPageUrl(): string | null;
-    /** The page links Laravel renders: previous, the page window with '...' gaps, next. */
+    /**
+     * The page links Laravel renders: previous, the page window with '...' gaps, next. The labels are plain text
+     * ("« Previous", "Next »"), not Laravel's `&laquo;` entities, so a page can print them as text.
+     */
     linkCollection(): PaginationLink[];
     /** Laravel's UrlWindow: the first pages, the slider around the current page and the last pages, with '...' between. */
     protected elements(): Array<UrlRange | '...'>;
@@ -4820,6 +4946,13 @@ declare class Grammar {
     compileOrders(query: Builder$1<unknown>): Sql | undefined;
     compileWheres(wheres: readonly Where[], keyword?: 'where' | 'on'): Sql | undefined;
     compileWhere(where: Where): Sql;
+    /**
+     * whereLike() per driver, as Laravel 12's grammars: Postgres compares the column as text with ilike (like when
+     * case-sensitive); MySQL uses like (like binary); SQLite uses like, or glob with the pattern translated.
+     */
+    compileWhereLike(where: Extract<Where, {
+        type: 'like';
+    }>): Sql;
     compileJoin(joinClause: JoinClause): Sql;
     compileHavings(havings: readonly Having[]): Sql | undefined;
     compileLimitOffset(limit: number | undefined, offset: number | undefined): Sql | undefined;
@@ -4867,6 +5000,13 @@ type Where = {
     values: readonly [unknown, unknown];
     not: boolean;
     boolean: WhereBoolean;
+} | {
+    type: 'like';
+    column: ColumnRef;
+    value: string;
+    caseSensitive: boolean;
+    not: boolean;
+    boolean: WhereBoolean;
 } | {
     type: 'column';
     first: ColumnRef;
@@ -4909,6 +5049,8 @@ type SelectColumn = ColumnRef | {
     as: string;
 };
 type NestedCallback<Q> = (query: Q) => unknown;
+/** The value when()'s callback receives: the condition's type without its falsy members. */
+type Truthy<V> = Exclude<V, false | 0 | 0n | '' | null | undefined>;
 /** The key a selected column comes back under: 'users.name' → 'name', 'name as n' → 'n'. */
 declare function columnKey(column: string): string;
 /**
@@ -4959,6 +5101,16 @@ declare class Builder$1<T = Row$4> implements QueryBuilder$4<T> {
     whereBetween(column: ColumnRef, values: readonly [unknown, unknown]): this;
     orWhereBetween(column: ColumnRef, values: readonly [unknown, unknown]): this;
     whereNotBetween(column: ColumnRef, values: readonly [unknown, unknown]): this;
+    /**
+     * Laravel's whereLike(): the value is the pattern, `%` and `_` included (`whereLike('title', `%${term}%`)`).
+     * Case-insensitive unless caseSensitive: ilike on Postgres, like on MySQL and SQLite (their like already ignores
+     * case: MySQL through the column's collation, SQLite for ASCII letters). Case-sensitive is like on Postgres,
+     * like binary on MySQL and glob on SQLite.
+     */
+    whereLike(column: ColumnRef, value: string, caseSensitive?: boolean, boolean?: WhereBoolean, not?: boolean): this;
+    orWhereLike(column: ColumnRef, value: string, caseSensitive?: boolean): this;
+    whereNotLike(column: ColumnRef, value: string, caseSensitive?: boolean, boolean?: WhereBoolean): this;
+    orWhereNotLike(column: ColumnRef, value: string, caseSensitive?: boolean): this;
     /** Compares two columns: whereColumn('updated_at', '>', 'created_at'). */
     whereColumn(first: ColumnRef, operatorOrSecond: string, second?: ColumnRef, boolean?: WhereBoolean): this;
     orWhereColumn(first: ColumnRef, operatorOrSecond: string, second?: ColumnRef): this;
@@ -4993,8 +5145,20 @@ declare class Builder$1<T = Row$4> implements QueryBuilder$4<T> {
     forPage(page: number, perPage?: number): this;
     lockForUpdate(): this;
     sharedLock(): this;
-    /** Calls callback(this, value) when value is truthy (or the default callback otherwise). */
-    when<V>(value: V, callback: (query: this, value: V) => unknown, otherwise?: (query: this, value: V) => unknown): this;
+    /**
+     * Laravel's when(): callback(query, value) runs when the value is truthy, otherwise(query, value) when it is falsy.
+     * A function value is called with the query first and its result is the value. Truthiness is JavaScript's, so `'0'`
+     * and `[]` are truthy: a `?active=0` filter applies, where Laravel would skip it. Returns the query; what the
+     * callbacks return is ignored.
+     *
+     * @example
+     * Post.query().when(request.query('q'), (query, q) => query.whereLike('title', `%${q}%`))
+     */
+    when<V>(value: (query: this) => V, callback: (query: this, value: Truthy<V>) => unknown, otherwise?: (query: this, value: V) => unknown): this;
+    when<V>(value: V, callback: (query: this, value: Truthy<V>) => unknown, otherwise?: (query: this, value: V) => unknown): this;
+    /** Laravel's unless(): when() with the condition reversed. callback(query, value) runs when the value is falsy. */
+    unless<V>(value: (query: this) => V, callback: (query: this, value: V) => unknown, otherwise?: (query: this, value: Truthy<V>) => unknown): this;
+    unless<V>(value: V, callback: (query: this, value: V) => unknown, otherwise?: (query: this, value: Truthy<V>) => unknown): this;
     tap(callback: (query: this) => unknown): this;
     get(): Promise<Collection<T>>;
     /** The raw rows, without a Collection around them. */
@@ -5315,6 +5479,10 @@ declare class Builder<M extends Model = Model> extends Builder$1<M> {
     whereNull(columns: Column<M> | Expression | Array<Column<M> | Expression>): this;
     whereNotNull(columns: Column<M> | Expression | Array<Column<M> | Expression>): this;
     whereBetween(column: Column<M> | Expression, values: readonly [unknown, unknown]): this;
+    whereLike(column: Column<M> | Expression, value: string, caseSensitive?: boolean, boolean?: WhereBoolean, not?: boolean): this;
+    orWhereLike(column: Column<M> | Expression, value: string, caseSensitive?: boolean): this;
+    whereNotLike(column: Column<M> | Expression, value: string, caseSensitive?: boolean, boolean?: WhereBoolean): this;
+    orWhereNotLike(column: Column<M> | Expression, value: string, caseSensitive?: boolean): this;
     orderBy(column: Column<M> | Expression, direction?: Direction | Uppercase<Direction>): this;
     /** Newest first by the model's created_at column (or the given one). */
     latest(column?: Column<M> | Expression): this;
@@ -5900,12 +6068,21 @@ declare class Model implements ModelInstance$2 {
     /** A new query of this model, with its global scopes. */
     static query<C extends typeof Model>(this: C): ModelBuilder<C>;
     static where<C extends typeof Model>(this: C, ...args: WhereArgs<Instance<C>, ModelBuilder<C>>): ModelBuilder<C>;
+    /** Post.when(request.query('q'), (query, q) => query.whereLike('title', `%${q}%`)): a new query, then when(). */
+    static when<C extends typeof Model, V>(this: C, value: (query: ModelBuilder<C>) => V, callback: (query: ModelBuilder<C>, value: Truthy<V>) => unknown, otherwise?: (query: ModelBuilder<C>, value: V) => unknown): ModelBuilder<C>;
+    static when<C extends typeof Model, V>(this: C, value: V, callback: (query: ModelBuilder<C>, value: Truthy<V>) => unknown, otherwise?: (query: ModelBuilder<C>, value: V) => unknown): ModelBuilder<C>;
+    /** A new query, then unless(): the callback runs when the value is falsy. */
+    static unless<C extends typeof Model, V>(this: C, value: (query: ModelBuilder<C>) => V, callback: (query: ModelBuilder<C>, value: V) => unknown, otherwise?: (query: ModelBuilder<C>, value: Truthy<V>) => unknown): ModelBuilder<C>;
+    static unless<C extends typeof Model, V>(this: C, value: V, callback: (query: ModelBuilder<C>, value: V) => unknown, otherwise?: (query: ModelBuilder<C>, value: Truthy<V>) => unknown): ModelBuilder<C>;
     static whereKey<C extends typeof Model>(this: C, id: unknown): ModelBuilder<C>;
     static whereIn<C extends typeof Model>(this: C, column: Column<Instance<C>> | Expression, values: readonly unknown[]): ModelBuilder<C>;
     static whereNotIn<C extends typeof Model>(this: C, column: Column<Instance<C>> | Expression, values: readonly unknown[]): ModelBuilder<C>;
     static whereNull<C extends typeof Model>(this: C, column: Column<Instance<C>> | Expression): ModelBuilder<C>;
     static whereNotNull<C extends typeof Model>(this: C, column: Column<Instance<C>> | Expression): ModelBuilder<C>;
     static whereBetween<C extends typeof Model>(this: C, column: Column<Instance<C>> | Expression, values: readonly [unknown, unknown]): ModelBuilder<C>;
+    /** Post.whereLike('title', `%${term}%`): case-insensitive unless caseSensitive (see the query builder's whereLike()). */
+    static whereLike<C extends typeof Model>(this: C, column: Column<Instance<C>> | Expression, value: string, caseSensitive?: boolean): ModelBuilder<C>;
+    static whereNotLike<C extends typeof Model>(this: C, column: Column<Instance<C>> | Expression, value: string, caseSensitive?: boolean): ModelBuilder<C>;
     static whereColumn<C extends typeof Model>(this: C, first: Column<Instance<C>>, operatorOrSecond: string, second?: Column<Instance<C>>): ModelBuilder<C>;
     static whereRaw<C extends typeof Model>(this: C, sql: string, bindings?: readonly unknown[]): ModelBuilder<C>;
     static select<C extends typeof Model>(this: C, ...columns: Array<Column<Instance<C>> | Expression>): ModelBuilder<C>;
@@ -6218,6 +6395,82 @@ declare class Pivot extends Model {
     timestamps: boolean;
 }
 
+/**
+ * Laravel's DatabaseNotification: one row of the `notifications` table, which the database channel writes. A UUID
+ * string key, `data` as an array cast and `read_at` as a datetime. `user.notifications()` returns these, newest first.
+ */
+declare class DatabaseNotification extends Model implements DatabaseNotification$1 {
+    protected table: string | undefined;
+    protected keyType: 'int' | 'string';
+    incrementing: boolean;
+    protected guarded: string[];
+    protected casts: Readonly<Record<string, CastDefinition>>;
+    $attributes?: {
+        id: string;
+        type: string;
+        notifiable_type: string;
+        notifiable_id: number | string;
+        data: Record<string, unknown>;
+        read_at: Date | null;
+        created_at: Date | null;
+        updated_at: Date | null;
+    };
+    readonly id: string;
+    readonly type: string;
+    readonly notifiable_type: string;
+    readonly notifiable_id: number | string;
+    readonly data: Record<string, unknown>;
+    read_at: Date | null;
+    readonly created_at: Date | null;
+    readonly updated_at: Date | null;
+    /** The model the notification was sent to. */
+    notifiable<R extends Model = Model>(): MorphTo<R, this>;
+    /** Sets read_at to now and saves, unless it is already read. */
+    markAsRead(): Promise<void>;
+    /** Clears read_at and saves, unless it is already unread. */
+    markAsUnread(): Promise<void>;
+    read(): boolean;
+    unread(): boolean;
+    /** `query.read()`: only read notifications. */
+    static scopeRead(query: Builder<DatabaseNotification>): Builder<DatabaseNotification>;
+    /** `query.unread()`: only unread notifications. */
+    static scopeUnread(query: Builder<DatabaseNotification>): Builder<DatabaseNotification>;
+}
+/** Laravel's DatabaseNotificationCollection: what `await user.notifications().get()` returns. */
+declare class DatabaseNotificationCollection extends Collection<DatabaseNotification> {
+    /** Marks every notification as read (one save each, as in Laravel). */
+    markAsRead(): Promise<void>;
+    /** Marks every notification as unread. */
+    markAsUnread(): Promise<void>;
+}
+/**
+ * The relation `notifications()`, `readNotifications()` and `unreadNotifications()` return: a morphMany over
+ * DatabaseNotification whose results (get(), the loaded relation, eager loads) are DatabaseNotificationCollections.
+ * Every builder method works on it: paginate(), count(), update({ read_at }), where(), …
+ */
+declare class DatabaseNotificationsRelation<P extends Model = Model> extends MorphMany<DatabaseNotification, P> {
+    get(): Promise<DatabaseNotificationCollection>;
+    getResults(): Promise<DatabaseNotificationCollection>;
+    initRelation(models: P[], relation: string): P[];
+    match(models: P[], results: DatabaseNotification[], relation: string): P[];
+}
+
+type ModelConstructor = new (...args: any[]) => Model;
+/** What HasDatabaseNotifications adds to a model. */
+interface HasDatabaseNotificationsModel extends Model {
+    /** The model's notifications, newest first: morphMany(DatabaseNotification, 'notifiable').latest(). */
+    notifications(): DatabaseNotificationsRelation<this>;
+    /** The read ones (read_at set). */
+    readNotifications(): DatabaseNotificationsRelation<this>;
+    /** The unread ones (read_at null). */
+    unreadNotifications(): DatabaseNotificationsRelation<this>;
+}
+/**
+ * Laravel's HasDatabaseNotifications: the notifications the database channel stored for this model, as queries.
+ * `class User extends HasDatabaseNotifications(Model) {}`; apps get it through `Notifiable`.
+ */
+declare function HasDatabaseNotifications<TBase extends ModelConstructor>(Base: TBase): TBase & (new (...args: any[]) => HasDatabaseNotificationsModel);
+
 /**
  * The morph map: the value stored in `*_type` columns for each model class (Laravel's Relation::morphMap()).
  * Without an entry the class name is stored ('Post'). Returns the current map.
@@ -6535,7 +6788,11 @@ declare class RouteModelResolverImpl implements RouteModelResolver {
 
 /** Laravel 11's config/database.php defaults (the app's config/database.ts wins, key by key). */
 declare function databaseConfigDefaults(app: Pick<Application$4, 'databasePath'>): DatabaseConfig & Record<string, unknown>;
-/** Points the paginators at the current request: ?page=, ?cursor=, the URL and the query string (Laravel's resolvers). */
+/**
+ * Points the paginators at the current request: ?page=, ?cursor=, the URL and the query string (Laravel's resolvers).
+ * A bound PaginationState is asked first for the page and the path (Livewire's WithPagination replaces Laravel's
+ * resolvers the same way); what it leaves undefined comes from the request.
+ */
 declare function usePaginationResolvers(): void;
 /**
  * Binds the database layer: the DatabaseManager (a root singleton owning the pools) behind the DB facade, the
@@ -8279,6 +8536,8 @@ interface ModelInstance$1 {
     getTable(): string;
     getRouteKey(): unknown;
     getRouteKeyName(): string;
+    /** The value stored in a polymorphic `*_type` column for this model: its morph map alias, else its class name. */
+    getMorphClass(): string;
     getAttribute<T = unknown>(key: string): T;
     setAttribute(key: string, value: unknown): this;
     fill(attributes: Row$2): this;
@@ -8360,18 +8619,18 @@ interface MustVerifyEmail {
     getEmailForVerification(): string;
 }
 
-interface Notifiable {
+interface Notifiable$1 {
     /** e.g. 'mail' → email address, 'database' → the model itself. */
     routeNotificationFor(channel: string, notification: Notification): unknown;
 }
 interface Notification {
     /** Optional id; set by the dispatcher when missing. */
     id?: string;
-    via(notifiable: Notifiable): string[];
+    via(notifiable: Notifiable$1): string[];
     /** Returns a Mailable (Contracts/Mail) or the Notifications MailMessage builder. */
-    toMail?(notifiable: Notifiable): unknown;
-    toDatabase?(notifiable: Notifiable): Record<string, unknown>;
-    toArray?(notifiable: Notifiable): Record<string, unknown>;
+    toMail?(notifiable: Notifiable$1): unknown;
+    toDatabase?(notifiable: Notifiable$1): Record<string, unknown>;
+    toArray?(notifiable: Notifiable$1): Record<string, unknown>;
 }
 
 declare abstract class ServiceProvider$b implements ServiceProvider$u {
@@ -8853,6 +9112,42 @@ declare class AccessGate implements Gate$1 {
     getPolicyFor(target: unknown): PolicyClass | undefined;
 }
 
+type AuthorizableConstructor = new (...args: any[]) => Authenticatable;
+/**
+ * Laravel's Authorizable trait: `user.can('update', post)` asks the Gate about this user (Gate.forUser), whoever is
+ * signed in. `class User extends Authorizable(AuthenticatableModel(Model)) {}`.
+ */
+declare function Authorizable<TBase extends AuthorizableConstructor>(Base: TBase): {
+    new (...args: any[]): {
+        /** Whether the user has the ability (every one, for a list); the arguments go to the policy or ability callback. */
+        can(abilities: string | readonly string[], ...args: unknown[]): Promise<boolean>;
+        /** Whether the user has any of the abilities. */
+        canAny(abilities: string | readonly string[], ...args: unknown[]): Promise<boolean>;
+        /** Whether the user lacks the ability (any one, for a list). */
+        cant(abilities: string | readonly string[], ...args: unknown[]): Promise<boolean>;
+        /** The same as cant(). */
+        cannot(abilities: string | readonly string[], ...args: unknown[]): Promise<boolean>;
+        getAuthIdentifierName(): string;
+        getAuthIdentifier(): unknown;
+        getAuthPassword(): string;
+        getRememberToken(): string | undefined;
+        setRememberToken(value: string): void;
+        getRememberTokenName(): string;
+    };
+} & TBase;
+
+/**
+ * The framework's base controller, with Laravel's AuthorizesRequests: `await this.authorize('update', post)` throws an
+ * AuthorizationError (403, or the status the policy chose) unless the signed-in user may. The app's
+ * `app/Http/Controllers/Controller.ts` extends it.
+ */
+declare abstract class Controller {
+    /** Authorizes the ability for the signed-in user (the Gate's authorize()). */
+    protected authorize(ability: string, ...args: unknown[]): Promise<void>;
+    /** Authorizes the ability for the given user (Gate.forUser(user).authorize()). */
+    protected authorizeForUser(user: Authenticatable | undefined, ability: string, ...args: unknown[]): Promise<void>;
+}
+
 /**
  * Laravel's Authorize middleware (`can:update,post`). Each extra parameter is a quoted literal ('"draft"'), else the
  * route parameter of that name (the bound model), else the name itself (a model name such as `Post`, which selects
@@ -9279,6 +9574,11 @@ interface OrielError$6 extends Error {
 
 /** Options a job class may declare as public fields. Their presence (or implementing ShouldQueue) makes things queueable. */
 interface ShouldQueue$3 {
+    /**
+     * Marks the class as queued at run time: `implements ShouldQueue` leaves no trace once compiled, so the interface
+     * asks for `readonly shouldQueue = true`. Jobs, listeners, mailables and notifications carrying it are queued.
+     */
+    readonly shouldQueue: true;
     connection?: string;
     queue?: string;
     /** Seconds. */
@@ -9457,15 +9757,15 @@ declare class Dispatcher$1 implements EventDispatcher {
 declare const QUEUE_OPTION_KEYS: readonly ["connection", "queue", "delay", "tries", "backoff", "timeout"];
 type QueueOptionKey = (typeof QUEUE_OPTION_KEYS)[number];
 /**
- * Whether a listener opts into queueing. `implements ShouldQueue` leaves no runtime trace, so this is structural,
- * like the Queue/Bus protocol's own `isQueueable(job)`: the marker, or an option, or a `uniqueId`/`retryUntil`
- * method. Unlike a job (already an instance by the time Bus sees it), a listener is a *class* registered with
- * `listen()`, so Events must build it first — `this.container.make(cls)` is cheap and side-effect-free for listener
- * classes, which have DI-only constructors — and then applies the protocol rule to that instance: the marker
- * (readable off the instance through the prototype chain), an **instance** option field with a defined value, or an
- * instance `uniqueId`/`retryUntil` method — the same fields Mail's and Notifications' `isQueueableMailable`/
- * equivalent read. A **static** field or method on the class counts too, as an extra on top of the protocol rule
- * (not instead of it), so an existing `static queue = '...'` listener still works.
+ * Whether a listener opts into queueing, like the Queue/Bus protocol's own `isQueueable(job)`: ShouldQueue's
+ * `shouldQueue: true`, the SHOULD_QUEUE symbol, an option, or a `uniqueId`/`retryUntil` method. Unlike a job (already
+ * an instance by the time Bus sees it), a listener is a *class* registered with `listen()`, so Events must build it
+ * first — `this.container.make(cls)` is cheap and side-effect-free for listener classes, which have DI-only
+ * constructors — and then applies the protocol rule to that instance: the marker (readable off the instance through
+ * the prototype chain), an **instance** option field with a defined value, or an instance `uniqueId`/`retryUntil`
+ * method — the same fields Mail's and Notifications' `isQueueableMailable`/equivalent read. A **static** field or
+ * method on the class (`shouldQueue`, an option, `uniqueId`/`retryUntil`) counts too, as an extra on top of the
+ * protocol rule (not instead of it), so an existing `static queue = '...'` listener still works.
  */
 declare function isQueueableListener(cls: Class$6<unknown>, instance: object): boolean;
 /**
@@ -10379,9 +10679,17 @@ declare class S3Filesystem implements Filesystem {
     get(path: string): Promise<string>;
     getBytes(path: string): Promise<Uint8Array>;
     readStream(path: string): Promise<ReadableStream<Uint8Array>>;
+    /** Sends the type of the path when the options name none (Laravel's S3 adapter detects one too). */
     put(path: string, contents: string | Uint8Array | ReadableStream<Uint8Array>, options?: PutOptions): Promise<boolean>;
     putFile(directory: string, file: UploadedFile$1, options?: PutOptions): Promise<string>;
+    /**
+     * Sends the upload's own type: its extension(), which follows what a request upload's bytes show (the client's claim
+     * counts only where extension() keeps it). Never the MIME type the client sent as such, nor the name it is stored
+     * under (an app may name it after the client's file name): S3, or a CDN in front of it, serves the object with this
+     * type. An upload of no known type is sent with none (served as binary).
+     */
     putFileAs(directory: string, file: UploadedFile$1, name: string, options?: PutOptions): Promise<string>;
+    private putObject;
     delete(paths: string | string[]): Promise<boolean>;
     copy(from: string, to: string): Promise<boolean>;
     move(from: string, to: string): Promise<boolean>;
@@ -10578,6 +10886,8 @@ interface ModelInstance {
     getTable(): string;
     getRouteKey(): unknown;
     getRouteKeyName(): string;
+    /** The value stored in a polymorphic `*_type` column for this model: its morph map alias, else its class name. */
+    getMorphClass(): string;
     getAttribute<T = unknown>(key: string): T;
     setAttribute(key: string, value: unknown): this;
     fill(attributes: Row): this;
@@ -10590,6 +10900,11 @@ interface ModelInstance {
 
 /** Options a job class may declare as public fields. Their presence (or implementing ShouldQueue) makes things queueable. */
 interface ShouldQueue$2 {
+    /**
+     * Marks the class as queued at run time: `implements ShouldQueue` leaves no trace once compiled, so the interface
+     * asks for `readonly shouldQueue = true`. Jobs, listeners, mailables and notifications carrying it are queued.
+     */
+    readonly shouldQueue: true;
     connection?: string;
     queue?: string;
     /** Seconds. */
@@ -11423,6 +11738,11 @@ interface OrielError$2 extends Error {
 
 /** Options a job class may declare as public fields. Their presence (or implementing ShouldQueue) makes things queueable. */
 interface ShouldQueue$1 {
+    /**
+     * Marks the class as queued at run time: `implements ShouldQueue` leaves no trace once compiled, so the interface
+     * asks for `readonly shouldQueue = true`. Jobs, listeners, mailables and notifications carrying it are queued.
+     */
+    readonly shouldQueue: true;
     connection?: string;
     queue?: string;
     /** Seconds. */
@@ -11595,8 +11915,9 @@ interface UniqueLockSpec {
     untilProcessing: boolean;
 }
 /**
- * Whether dispatch() queues the job: it carries the ShouldQueue marker (the Queueable base class), has a value for
- * any ShouldQueue option, or defines uniqueId()/retryUntil(). `implements ShouldQueue` alone leaves no runtime trace.
+ * Whether dispatch() queues the job: it carries ShouldQueue's `shouldQueue: true` (a `readonly shouldQueue = true`
+ * field, or the Queueable base class's getter), the SHOULD_QUEUE symbol, a value for any ShouldQueue option, or
+ * defines uniqueId()/retryUntil().
  */
 declare function isQueueable(job: unknown): boolean;
 /** Laravel's ShouldBeUnique: the job defines uniqueId(), uniqueFor, uniqueUntilProcessing or uniqueVia(). */
@@ -11753,7 +12074,9 @@ declare abstract class Dispatchable implements Job$1 {
  * A queued job: Laravel's `implements ShouldQueue` + `use Queueable`. `dispatch()` pushes it onto the queue.
  * The marker lives on the prototype, so it is never serialized.
  */
-declare abstract class Queueable extends Dispatchable {
+declare abstract class Queueable extends Dispatchable implements ShouldQueue$1 {
+    /** ShouldQueue's marker, so subclasses may write `implements ShouldQueue` without the field. */
+    get shouldQueue(): true;
 }
 
 /** Laravel's dispatch() helper: queued when the job is queueable, else run now. Dispatched once, awaited or not. */
@@ -11814,6 +12137,11 @@ interface OrielError$1 extends Error {
 
 /** Options a job class may declare as public fields. Their presence (or implementing ShouldQueue) makes things queueable. */
 interface ShouldQueue {
+    /**
+     * Marks the class as queued at run time: `implements ShouldQueue` leaves no trace once compiled, so the interface
+     * asks for `readonly shouldQueue = true`. Jobs, listeners, mailables and notifications carrying it are queued.
+     */
+    readonly shouldQueue: true;
     connection?: string;
     queue?: string;
     /** Seconds. */
@@ -12135,6 +12463,17 @@ declare class MailServiceProvider extends ServiceProvider$2 {
     register(): void;
 }
 
+/**
+ * Laravel's Notifiable trait: RoutesNotifications (notify(), notifyNow(), routeNotificationFor()) and
+ * HasDatabaseNotifications (notifications(), unreadNotifications(), readNotifications()).
+ * `class User extends Notifiable(AuthenticatableModel(Model)) {}`.
+ */
+declare function Notifiable<TBase extends ModelConstructor>(Base: TBase): (new (...args: any[]) => {
+    routeNotificationFor(channel: string, notification: Notification$4): unknown;
+    notify(notification: Notification$4): Promise<void>;
+    notifyNow(notification: Notification$4, channels?: string[]): Promise<void>;
+}) & TBase & (new (...args: any[]) => HasDatabaseNotificationsModel);
+
 /** A typed, runtime-unique key for container bindings. */
 interface Token<T> {
     readonly id: symbol;
@@ -12921,4 +13260,4 @@ type SharedPropsFrom<M> = M extends {
     share(...args: never[]): infer R;
 } ? SerializedObject<Awaited<R>> : Record<never, never>;
 
-export { API_ROUTES_STUB, AboutCommand, AbstractPaginator, AccessGate, AddQueuedCookiesToResponse, type AfterCallback, AllMailersFailedError, AlwaysProp, AnonymousNotifiable, Application$9 as Application, ApplicationBuilder, ArgonHasher, type ArgonOptions, type ArgumentDefinition, Arr, ArraySessionHandler, ArrayTransport, Artisan, Attempting, type Attributes$1 as Attributes, type AttributesResolver, Auth, AuthManager, type AuthModel, type AuthModelBase, type AuthModelConstructor, AuthServiceProvider, AuthenticatableModel, Authenticate, AuthenticationError, AuthorizationError, AuthorizationErrorImpl, Authorize, BaseJob, BaseLogger, BasePipeline, BaseRouter, BaseUrlGenerator, Batch$1 as Batch, type BatchAttributes, BatchingUnavailableError, BcryptHasher, type BcryptOptions, type BeforeCallback, BelongsTo, BelongsToMany, BindingResolutionError, Blueprint, type BlueprintCommand, BufferedConsoleOutput, Builder, type BuiltInCast, type BuiltinRule, BuiltinRuleObject, type BunDatabase, BunSqliteDatabase, type BunStatement, Bus, Dispatcher as BusDispatcherImpl, BusError, BusServiceProvider, CACHE_TABLE_MIGRATION, CHAIN, Cache, CacheManager$1 as CacheManager, CacheRateLimiter, Repository as CacheRepositoryImpl, CacheServiceProvider, type Store as CacheStore, CallQueuedHandler, CallQueuedListener, type CanResetPassword, type CanResetPasswordUser, type CastDefinition, type CastsAttributes, type ChainSpec, type CipherName, CircularDependencyError, ClassRegistry$2 as ClassRegistry, ClosureCommand$4 as ClosureCommand, ClosureKernel, Collection$2 as Collection, type Column, type ColumnAttributes, ColumnDefinition, type ColumnInfo, type ColumnRef, type ColumnType, Command$4 as Command, CommandNotFoundError, ComponentNotFoundError, Connection, type ConsoleInput, type ConsoleIo, Kernel as ConsoleKernelImpl, type ConsoleOutput, ConsoleServiceProvider, Container$j as Container, ContainerNotAvailableError, ControllerMethodNotFoundError, ConvertEmptyStringsToNull, Cookie$1 as Cookie, type CookieDefaults, CookieJar$1 as CookieJar, CookieServiceProvider, CookieSessionHandler, CookieValuePrefix, type CreateMigrationOptions, Crypt, Cursor, type CursorPage, CursorPaginator, type CursorPaginatorOptions, DB, DEFAULT_MESSAGES, DailyRotatingStream, DatabaseBatchRepository, type DatabaseCommandContext, type DatabaseConfig, DatabaseConfigError, DatabaseError, DatabaseFailedJobProvider, DatabaseJob, type DatabaseJobRecord, DatabaseLock, DatabaseManagerImpl, DatabaseNotificationChannel, type DatabaseNotificationRecord, DatabaseQueue, type DatabaseQueueOptions, DatabaseServiceProvider, DatabaseSessionHandler, DatabaseStore, DatabaseTokenRepository, DatabaseUnavailableError, DecryptError, DeferProp, type Direction, Dispatchable, type EagerLoadSpec, EloquentUserProvider, EmailVerificationRequest, type Encoded, EncryptCookies, EncryptError, EncryptHistory, Encrypter$2 as Encrypter, EncryptionServiceProvider, EnsureEmailIsVerified, type EnumLike, type ErrorClass, ErrorHandler, Event, Dispatcher$1 as EventDispatcherImpl, type EventKey, type EventListenMap, EventServiceProvider, EventsNeedBusDispatcherError, EventsNeedClassRegistryError, ExceptionsConfiguration, Expression, type Facade$c as Facade, type FacadeStatics$c as FacadeStatics, Factory$b as Factory, type FactoryResult, Failed, FailoverTransport, Faker, FakerOverflowError, FileNotFoundError, FileSessionHandler, FileStore, FilesystemManager, FilesystemServiceProvider, ForeignIdColumnDefinition, ForeignKeyDefinition, FormRequest, FormUploadedFile, Gate, type GateAbility, GateResponse, GeneratorCommand, GenericLock, type GlobalScope, Grammar, type GroupAttributes, type GroupHost, GroupRegistrar, type GuardFactory, HasApiTokens, type HasFactory, HasMany, HasManyThrough, HasOne, HasOneOrMany, Hash, HashAlgorithmError, type HashInfo, HashManager, type HasherFactory, type HashingConfig, HashingServiceProvider, type Having, HelpCommand, type HttpCommandOptions, HttpException, Kernel$1 as HttpKernelImpl, HttpRedirectResponse, HttpRedirector, HttpResponseException, HttpResponseFactory, HttpServerError, HttpServiceProvider, Hub, IncomingRequest, type IncomingRequestOptions, type IndexType, Inertia, InertiaError, InertiaHtml, InertiaMiddleware, Response$1 as InertiaPageResponse, ResponseFactory as InertiaResponseFactory, InertiaServiceProvider, type ValidationErrors as InertiaValidationErrors, type InferRuleType, type InferValidatedType, InvalidCacheConfigError, InvalidCastError, InvalidListenerError, InvalidLogLevelError, InvalidRuleParameterError, InvalidSignatureError, InvalidUrlSignatureError, JOBS_TABLE_MIGRATION, JobClassNotFoundError, type JobContext, type JobMiddleware, JobSerializationError, JoinClause, type JoinType, type JsonWhenCallback, KEY_GENERATE_SIGNATURE, type KernelApp, type KeyGenerateIO, LEVEL_SEVERITY, LazyCollection$1 as LazyCollection, type LengthAwarePage, LengthAwarePaginator, ListCommand, type ListenerTuple, type LocalDiskConfig, LocalFilesystem, type LockFactory, LockTimeoutError, Lockout, Log, LogChannelCycleError, LogManager, LogServiceProvider, LogTransport, type LoggedQuery, LogicError, Login, Logout, MIGRATION_CREATE_STUB, MIGRATION_STUB, MIGRATION_UPDATE_STUB, MODEL_EVENTS, Mail, MailManager, MailMessage, type MailMessageAction, MailNotificationChannel, MailQueueUnavailableError, MailServiceProvider, type MailTransporter, MailUnavailableError, Mailable, MailerImpl, MakeCastCommand, MakeCommandCommand, MakeControllerCommand, MakeEventCommand, MakeFactoryCommand, MakeJobCommand, MakeListenerCommand, MakeMailCommand, MakeMiddlewareCommand, MakeModelCommand, MakeNotificationCommand, MakeObserverCommand, MakePolicyCommand, MakeProviderCommand, MakeRequestCommand, MakeResourceCommand, MakeRuleCommand, MakeSeederCommand, MakeTestCommand, type Manifest, type ManifestChunk, ManuallyFailedError, type Many, MassAssignmentError, MaxAttemptsExceededError, MemoryStore, MergeProp, MessageBagImpl, MethodNotAllowedHttpError, MiddlewareConfiguration, MiddlewareNotFoundError, Migration, MigrationCreator, type MigrationRecord, MigrationRepository, type MigrationStatus, Migrator, type MigratorOptions, MissingAppKeyError, MissingModelError, MissingRecipientError, Model, type ModelBuilder, type ModelClass, type ModelEvent, type ModelListener, ModelNotFoundError$1 as ModelNotFoundError, ModelRegistry, type MorphConstraint, MorphMany, MorphOne, MorphTo, MySqlSchemaGrammar, NOTIFICATIONS_TABLE, NOTIFICATIONS_TABLE_MIGRATION, type NewAccessToken, NodeConsoleInput, NodeConsoleOutput, NotDatabaseNotifiableError, NotFoundHttpError, Notifiable$1 as Notifiable, type NotifiableConstructor, Notification$1 as Notification, Dispatcher$2 as NotificationDispatcherImpl, NotificationDispatcherUnavailableError, NotificationFacade, NotificationQueueUnavailableError, NotificationsServiceProvider, NullFailedJobProvider, NullLogger, NullQueue, OPERATORS, OnceProp, type OptionDefinition, type OptionValue$4 as OptionValue, OptionalProp, type Order, PERSONAL_ACCESS_TOKENS_MIGRATION, type PagePropsFrom, type PaginationLink, Paginator, type PaginatorOptions, type ParsedInput, type ParsedRule, type ParsedSetCookie, type ParsedSignature, Password, PasswordBroker, PasswordBrokerManager, PasswordReset, PasswordRule, PathTraversalError, PendingBatch, PendingChain, PendingDispatch, PersonalAccessToken, PinoLogger, PipelineError, PipelineServiceProvider, Pivot, type PivotIds, type PlainNotificationMail, type PolicyClass, PostgresSchemaGrammar, type PreloadAttributesResolver, PropsResolver, ProviderBootError, ProviderRegisterError, QUEUE_JOB, Builder$1 as QueryBuilder, QueryError, Queue$1 as Queue, QueueBase, type QueueCommandContext, QueueError, type QueueJobPayload, QueueManager, QueueServiceProvider, QueueUnavailableError, Queueable, QueuedConsoleInput, QueuedMailSender, type QueuedMailableFactory, RESTART_CACHE_KEY, RateLimiter, type RawResult, type RecipientOverrides, RedirectIfAuthenticated, RedisJob, RedisLock, RedisQueue, type RedisQueueOptions, RedisRepository, type RedisSessionClient, RedisSessionHandler, RedisStore, RedisTaggedStore, type ReferentialAction, Registered, type RegisteredModel, Relation, type RelationConstraint, type RelationNames, RelationNotFoundError, RelationNotLoadedError, type RelationValue, type RenderCallback, type RenderedContent, type ReplStarter, type ReportCallback, Repository$1 as Repository, ResetPassword, type ResetPasswordMail, type ResolvedMiddleware, type ResolvedServeOptions, type ResourceMethod, type ResourceRoute, type RollbackOptions, Route$1 as Route, type RouteAttributes, type RouteBinder, RouteDefinition, type RouteFileCallback, type RouteHandler, type RouteListFilters, type RouteListRow, RouteModelNotFoundError, RouteModelResolverImpl, RouteNotDefinedError, type RouteStage, RoutingError, type RoutingOptions, RoutingServiceProvider, Rule, type RuleContext, type RunningServer, type Runtime, type S3ClientLike, type S3DiskConfig, S3Filesystem, SSR_RENDER_FAILED, STORAGE_LINK_SIGNATURE, Schedule, ScheduleImpl, ScheduleListCommand, ScheduleNameRequiredError, ScheduleRunCommand, ScheduleWorkCommand, type ScheduleWorkOptions, ScheduledEventImpl, Schema, SchemaBuilder, SchemaBuilderToken, SchemaGrammar, type Scope, type ScopeCallback, type ScopeStatic, type Scopes, type ScrollMetadata, ScrollProp, Seeder, type SeederClass, type SelectColumn, SendEmailVerificationNotification, SendQueuedMailable, SendQueuedNotifications, type Serialized, type SerializedObject, type ServeOptions, ServiceProvider$t as ServiceProvider, SessionFacade as Session, type SessionConfig, SessionGuard, type SessionGuardOptions, type SessionHandlerFactory, SessionManager, SessionMessageBag, SessionServiceProvider, Store$1 as SessionStore, type SharedPropsFrom, type SimplePage, type SmtpConfig, SmtpTransport, SoftDeletingScope, type SpawnResult, type Spawner, SqliteSchemaGrammar, SsrError, type SsrFailure, HttpGateway as SsrHttpGateway, type StackFrame, StackLogger, StartSession, type State, type StateContext, Storage, type StoredBatchOptions, Str, type StringPipeResolver, type SyncChanges, SyncJob, SyncQueue, type TagAttributes, TagsNotSupportedError, TestCommand, ThrottleRequests, ThrottleRequestsError, TimeoutExceededError, TinkerCommand, type TinkerOptions, type TinkerRepl, TokenGuard, type TokenGuardOptions, TokenMismatchError, TokenRepository, type TransporterFactory, TrimStrings, TypeGenerator, type TypeGeneratorOptions, type TypedRedirector, UNIQUE_LOCK, USERS_TABLE_MIGRATION, UniqueJobsNeedCacheError, UniqueLock, type UniqueLockSpec, UnknownCacheDriverError, UnknownCacheStoreError, UnknownDiskError, UnknownFilesystemDriverError, UnknownLogChannelError, UnknownLogDriverError, UnknownMailTransportError, UnknownMailerError, UnknownNotificationChannelError, UnknownQueueConnectionError, UnknownQueueDriverError, UnknownValidationRuleError, UnrenderableNotificationDataError, UnrenderableNotificationMailError, UnsupportedCipherError, UnsupportedOperationError, type UriParameter, UrlGenerationError, type UrlResolver, type UserProviderFactory, ValidateSignature, Validated, ValidationErrorImpl, ValidationException, ValidationFactoryImpl, ValidationServiceProvider, Validator, ValidatorImpl, type VerifiableUser, Verified, VerifyCsrfToken, VerifyEmail, type VerifyEmailMail, ViewFactoryUnavailableError, Vite, ViteError, ViteHtml, WORKER_DISCOVERY_DIRECTORIES, type Where, type WhereArgs, type WhereBoolean, WithoutOverlapping, Worker, type WorkerListener, type WorkerOptions, __, abort, abortIf, abortUnless, addApiRouting, allowGuests, app, applyExceptionCallbacks, applyMiddlewareCallbacks, applyReplacements, auth, back, bcrypt, builtinRules, bunRuntime, cache, castGet, castSet, classNameOf, clientAddress, collect, columnKey, compareRoutes, config, contentDisposition, cookie, createDailyChannel, createDialect, createPayload, createSingleChannel, createStderrChannel, createToken, csrfToken, currentContainer, currentLogContext, currentRequest, currentVite, databaseConfigDefaults, debugPage, decodePayload, decrypt, defaultAttributeName, defaultLockFactory, defaultProviders, defaultWorkerOptions, delaySeconds, describeError, deserialize, detectRuntime, discoverClasses, discoverFactories, discoverJobs, discoverListeners, discoverPolicies, dispatch, dispatchRoute, dispatchSync, encodePayload, encrypt, enumValues, env, errorBagFrom, errors, escapeHtml, event, exceedsJsonDepth, expandWildcardKeys, extensionFromMime, facade, fake, fetchNotifications, filterRouteList, formatAddress, formatDate, formatDateTime, formatRouteList, formatTimestamp, fromEntries, generateAppKey, generateModelTypes, getMorphAlias, getMorphedModel, guessTable, hashInfo, healthResponse, inertia, inertiaBody, inertiaHead, inject, ipMatches, isBlank, isBun, isDateCast, isEmptyValue, isEquivalent, isJsonCast, isListenerClass, isListenerTuple, isModel, isQueueable, isQueueableListener, isUnique, isUploadedFileLike, joinDiskPath, keyGenerateHandler, loadRelations, loadRoutesFrom, logger, makeFailedJobProvider, meetsLevel, mergeGroup, mergeLogContext, mergeRecursive, migrationDatePrefix, minimalPage, modelEventName, morphMap, normalizeAddress, normalizeAddresses, normalizeBackoff, normalizeLists, normalizePath, normalizeUri, now, old, openSqlite, optionalCookieJar, optionalSession, orderForBindings, parseArgv, parseBracketKey, parseCookieHeader, parseDateTime, parseKey, parseParameters, parseRuleSpec, parseSignature, passwordVerify, prepareValue, queueConfigDefaults, queueOptionsOf, raw as rawSql, rawWithBindings, redirect, registerHttpCommands, registerKeyGenerateCommand, registerMigrationCommands, registerModelTypesCommand, registerQueueCommands, registerStorageLinkCommand, renderContent, renderError, request, requestScope, resolveArguments, resolveDiskPath, resolveMiddleware, resolveMorphClass, resolveOptions, resourceRoutes, response, restoreJob, restoreValue, retry, roundTrip, route, routeListRows, runConsole, runConsoleAndExit, runMiddleware, runSeeder, sanitize, sendEmailVerificationUsing, sendNotification, serialize, serializeContext, serializeCookie, serializeDate, serializeValue, serve, serveBun, serveNode, servePublicFile, session, setClientAddress, stackFrames, statusFor, statusText, storageLinkHandler, substituteBindings, suggest, summarizeValidation, tap, toNotifiableList, toResponse, toWebRequest, tokenableType, transformLeaves, url, usePaginationResolvers, validateRequiredArguments, value, vite, viteReactRefresh, withHeaders, workerOptionsFrom, writeResponse };
+export { API_ROUTES_STUB, AboutCommand, AbstractPaginator, AccessGate, AddQueuedCookiesToResponse, type AfterCallback, AllMailersFailedError, AlwaysProp, AnonymousNotifiable, Application$9 as Application, ApplicationBuilder, ArgonHasher, type ArgonOptions, type ArgumentDefinition, Arr, ArraySessionHandler, ArrayTransport, Artisan, Attempting, type Attributes$1 as Attributes, type AttributesResolver, Auth, AuthManager, type AuthModel, type AuthModelBase, type AuthModelConstructor, AuthServiceProvider, AuthenticatableModel, Authenticate, AuthenticationError, Authorizable, type AuthorizableConstructor, AuthorizationError, AuthorizationErrorImpl, Authorize, BaseJob, BaseLogger, BasePipeline, BaseRouter, BaseUrlGenerator, Batch$1 as Batch, type BatchAttributes, BatchingUnavailableError, BcryptHasher, type BcryptOptions, type BeforeCallback, BelongsTo, BelongsToMany, BindingResolutionError, Blueprint, type BlueprintCommand, BufferedConsoleOutput, Builder, type BuiltInCast, type BuiltinRule, BuiltinRuleObject, type BunDatabase, BunSqliteDatabase, type BunStatement, Bus, Dispatcher as BusDispatcherImpl, BusError, BusServiceProvider, CACHE_TABLE_MIGRATION, CHAIN, Cache, CacheManager$1 as CacheManager, CacheRateLimiter, Repository as CacheRepositoryImpl, CacheServiceProvider, type Store as CacheStore, CallQueuedHandler, CallQueuedListener, type CanResetPassword, type CanResetPasswordUser, type CastDefinition, type CastsAttributes, type ChainSpec, type CipherName, CircularDependencyError, ClassRegistry$2 as ClassRegistry, ClosureCommand$4 as ClosureCommand, ClosureKernel, Collection$2 as Collection, type Column, type ColumnAttributes, ColumnDefinition, type ColumnInfo, type ColumnRef, type ColumnType, Command$4 as Command, CommandNotFoundError, ComponentNotFoundError, Connection, type ConsoleInput, type ConsoleIo, Kernel as ConsoleKernelImpl, type ConsoleOutput, ConsoleServiceProvider, Container$j as Container, ContainerNotAvailableError, Controller, ControllerMethodNotFoundError, ConvertEmptyStringsToNull, Cookie$1 as Cookie, type CookieDefaults, CookieJar$1 as CookieJar, CookieServiceProvider, CookieSessionHandler, CookieValuePrefix, type CreateMigrationOptions, Crypt, Cursor, type CursorPage, CursorPaginator, type CursorPaginatorOptions, DB, DEFAULT_MESSAGES, DailyRotatingStream, DatabaseBatchRepository, type DatabaseCommandContext, type DatabaseConfig, DatabaseConfigError, DatabaseError, DatabaseFailedJobProvider, DatabaseJob, type DatabaseJobRecord, DatabaseLock, DatabaseManagerImpl, DatabaseNotification, DatabaseNotificationChannel, DatabaseNotificationCollection, DatabaseNotificationsRelation, DatabaseQueue, type DatabaseQueueOptions, DatabaseServiceProvider, DatabaseSessionHandler, DatabaseStore, DatabaseTokenRepository, DatabaseUnavailableError, DecryptError, DeferProp, DiagnosingHealth, type Direction, Dispatchable, type EagerLoadSpec, EloquentUserProvider, EmailVerificationRequest, type Encoded, EncryptCookies, EncryptError, EncryptHistory, Encrypter$2 as Encrypter, EncryptionServiceProvider, EnsureEmailIsVerified, type EnumLike, type ErrorClass, ErrorHandler, Event, Dispatcher$1 as EventDispatcherImpl, type EventKey, type EventListenMap, EventServiceProvider, EventsNeedBusDispatcherError, EventsNeedClassRegistryError, ExceptionsConfiguration, Expression, type Facade$c as Facade, type FacadeStatics$c as FacadeStatics, Factory$b as Factory, type FactoryResult, Failed, FailoverTransport, Faker, FakerOverflowError, FileNotFoundError, FileSessionHandler, FileStore, FilesystemManager, FilesystemServiceProvider, ForeignIdColumnDefinition, ForeignKeyDefinition, FormRequest, FormUploadedFile, Gate, type GateAbility, GateResponse, GeneratorCommand, GenericLock, type GlobalScope, Grammar, type GroupAttributes, type GroupHost, GroupRegistrar, type GuardFactory, HasApiTokens, HasDatabaseNotifications, type HasDatabaseNotificationsModel, type HasFactory, HasMany, HasManyThrough, HasOne, HasOneOrMany, Hash, HashAlgorithmError, type HashInfo, HashManager, type HasherFactory, type HashingConfig, HashingServiceProvider, type Having, type HealthPage, HelpCommand, type HttpCommandOptions, HttpException, Kernel$1 as HttpKernelImpl, HttpRedirectResponse, HttpRedirector, HttpResponseException, HttpResponseFactory, HttpServerError, HttpServiceProvider, Hub, IncomingRequest, type IncomingRequestOptions, type IndexType, Inertia, InertiaError, InertiaHtml, InertiaMiddleware, Response$1 as InertiaPageResponse, ResponseFactory as InertiaResponseFactory, InertiaServiceProvider, type ValidationErrors as InertiaValidationErrors, type InferRuleType, type InferValidatedType, InvalidCacheConfigError, InvalidCastError, InvalidListenerError, InvalidLogLevelError, InvalidRuleParameterError, InvalidSignatureError, InvalidUrlSignatureError, JOBS_TABLE_MIGRATION, JobClassNotFoundError, type JobContext, type JobMiddleware, JobSerializationError, JoinClause, type JoinType, type JsonWhenCallback, KEY_GENERATE_SIGNATURE, type KernelApp, type KeyGenerateIO, LEVEL_SEVERITY, LazyCollection$1 as LazyCollection, type LengthAwarePage, LengthAwarePaginator, ListCommand, type ListenerTuple, type LocalDiskConfig, LocalFilesystem, type LockFactory, LockTimeoutError, Lockout, Log, LogChannelCycleError, LogManager, LogServiceProvider, LogTransport, type LoggedQuery, LogicError, Login, Logout, MIGRATION_CREATE_STUB, MIGRATION_STUB, MIGRATION_UPDATE_STUB, MODEL_EVENTS, Mail, MailManager, MailMessage, type MailMessageAction, MailNotificationChannel, MailQueueUnavailableError, MailServiceProvider, type MailTransporter, MailUnavailableError, Mailable, MailerImpl, MakeCastCommand, MakeCommandCommand, MakeControllerCommand, MakeEventCommand, MakeFactoryCommand, MakeJobCommand, MakeListenerCommand, MakeMailCommand, MakeMiddlewareCommand, MakeModelCommand, MakeNotificationCommand, MakeObserverCommand, MakePolicyCommand, MakeProviderCommand, MakeRequestCommand, MakeResourceCommand, MakeRuleCommand, MakeSeederCommand, MakeTestCommand, type Manifest, type ManifestChunk, ManuallyFailedError, type Many, MassAssignmentError, MaxAttemptsExceededError, MemoryStore, MergeProp, MessageBagImpl, MethodNotAllowedHttpError, MiddlewareConfiguration, MiddlewareNotFoundError, Migration, MigrationCreator, type MigrationRecord, MigrationRepository, type MigrationStatus, Migrator, type MigratorOptions, MissingAppKeyError, MissingModelError, MissingRecipientError, Model, type ModelBuilder, type ModelClass, type ModelConstructor, type ModelEvent, type ModelListener, ModelNotFoundError$1 as ModelNotFoundError, ModelRegistry, type MorphConstraint, MorphMany, MorphOne, MorphTo, MySqlSchemaGrammar, NOTIFICATIONS_TABLE, NOTIFICATIONS_TABLE_MIGRATION, type NewAccessToken, NodeConsoleInput, NodeConsoleOutput, NotDatabaseNotifiableError, NotFoundHttpError, Notifiable, type NotifiableConstructor, Notification$1 as Notification, Dispatcher$2 as NotificationDispatcherImpl, NotificationDispatcherUnavailableError, NotificationFacade, NotificationQueueUnavailableError, NotificationsServiceProvider, NullFailedJobProvider, NullLogger, NullQueue, OPERATORS, OnceProp, type OptionDefinition, type OptionValue$4 as OptionValue, OptionalProp, type Order, PERSONAL_ACCESS_TOKENS_MIGRATION, type PagePropsFrom, type PaginationLink, Paginator, type PaginatorOptions, type ParsedInput, type ParsedRule, type ParsedSetCookie, type ParsedSignature, Password, PasswordBroker, PasswordBrokerManager, PasswordReset, PasswordRule, PathTraversalError, PendingBatch, PendingChain, PendingDispatch, PersonalAccessToken, PinoLogger, PipelineError, PipelineServiceProvider, Pivot, type PivotIds, type PlainNotificationMail, type PolicyClass, PostgresSchemaGrammar, type PreloadAttributesResolver, PropsResolver, ProviderBootError, ProviderRegisterError, QUEUE_JOB, Builder$1 as QueryBuilder, QueryError, Queue$1 as Queue, QueueBase, type QueueCommandContext, QueueError, type QueueJobPayload, QueueManager, QueueServiceProvider, QueueUnavailableError, Queueable, QueuedConsoleInput, QueuedMailSender, type QueuedMailableFactory, RESTART_CACHE_KEY, RateLimiter, type RawResult, type RecipientOverrides, RedirectIfAuthenticated, RedisJob, RedisLock, RedisQueue, type RedisQueueOptions, RedisRepository, type RedisSessionClient, RedisSessionHandler, RedisStore, RedisTaggedStore, type ReferentialAction, Registered, type RegisteredModel, Relation, type RelationConstraint, type RelationNames, RelationNotFoundError, RelationNotLoadedError, type RelationValue, type RenderCallback, type RenderedContent, type ReplStarter, type ReportCallback, Repository$1 as Repository, ResetPassword, type ResetPasswordMail, type ResolvedMiddleware, type ResolvedServeOptions, type ResourceMethod, type ResourceRoute, type RollbackOptions, Route$1 as Route, type RouteAttributes, type RouteBinder, RouteDefinition, type RouteFileCallback, type RouteHandler, type RouteListFilters, type RouteListRow, RouteModelNotFoundError, RouteModelResolverImpl, RouteNotDefinedError, type RouteStage, RoutesNotifications, RoutingError, type RoutingOptions, RoutingServiceProvider, Rule, type RuleContext, type RunningServer, type Runtime, type S3ClientLike, type S3DiskConfig, S3Filesystem, SSR_RENDER_FAILED, STORAGE_LINK_SIGNATURE, Schedule, ScheduleImpl, ScheduleListCommand, ScheduleNameRequiredError, ScheduleRunCommand, ScheduleWorkCommand, type ScheduleWorkOptions, ScheduledEventImpl, Schema, SchemaBuilder, SchemaBuilderToken, SchemaGrammar, type Scope, type ScopeCallback, type ScopeStatic, type Scopes, type ScrollMetadata, ScrollProp, Seeder, type SeederClass, type SelectColumn, SendEmailVerificationNotification, SendQueuedMailable, SendQueuedNotifications, type Serialized, type SerializedObject, type ServeOptions, ServiceProvider$t as ServiceProvider, SessionFacade as Session, type SessionConfig, SessionGuard, type SessionGuardOptions, type SessionHandlerFactory, SessionManager, SessionMessageBag, SessionServiceProvider, Store$1 as SessionStore, type SharedPropsFrom, type SimplePage, type SmtpConfig, SmtpTransport, SoftDeletingScope, type SpawnResult, type Spawner, SqliteSchemaGrammar, SsrError, type SsrFailure, HttpGateway as SsrHttpGateway, type StackFrame, StackLogger, StartSession, type State, type StateContext, Storage, type StoredBatchOptions, Str, type StringPipeResolver, type SyncChanges, SyncJob, SyncQueue, type TagAttributes, TagsNotSupportedError, TestCommand, ThrottleRequests, ThrottleRequestsError, TimeoutExceededError, TinkerCommand, type TinkerOptions, type TinkerRepl, TokenGuard, type TokenGuardOptions, TokenMismatchError, TokenRepository, type TransporterFactory, TrimStrings, TypeGenerator, type TypeGeneratorOptions, type TypedRedirector, UNIQUE_LOCK, USERS_TABLE_MIGRATION, UniqueJobsNeedCacheError, UniqueLock, type UniqueLockSpec, UnknownCacheDriverError, UnknownCacheStoreError, UnknownDiskError, UnknownFilesystemDriverError, UnknownLogChannelError, UnknownLogDriverError, UnknownMailTransportError, UnknownMailerError, UnknownNotificationChannelError, UnknownQueueConnectionError, UnknownQueueDriverError, UnknownValidationRuleError, UnrenderableNotificationDataError, UnrenderableNotificationMailError, UnsupportedCipherError, UnsupportedOperationError, type UriParameter, UrlGenerationError, type UrlResolver, type UserProviderFactory, ValidateSignature, Validated, ValidationErrorImpl, ValidationException, ValidationFactoryImpl, ValidationServiceProvider, Validator, ValidatorImpl, type VerifiableUser, Verified, VerifyCsrfToken, VerifyEmail, type VerifyEmailMail, ViewFactoryUnavailableError, Vite, ViteError, ViteHtml, WORKER_DISCOVERY_DIRECTORIES, type Where, type WhereArgs, type WhereBoolean, WithoutOverlapping, Worker, type WorkerListener, type WorkerOptions, __, abort, abortIf, abortUnless, addApiRouting, allowGuests, app, applyExceptionCallbacks, applyMiddlewareCallbacks, applyReplacements, auth, back, bcrypt, builtinRules, bunRuntime, cache, castGet, castSet, classNameOf, clientAddress, collect, columnKey, compareRoutes, config, contentDisposition, cookie, createDailyChannel, createDialect, createPayload, createSingleChannel, createStderrChannel, createToken, csrfToken, currentContainer, currentLogContext, currentRequest, currentVite, databaseConfigDefaults, debugPage, decodePayload, decrypt, defaultAttributeName, defaultLockFactory, defaultProviders, defaultWorkerOptions, delaySeconds, describeError, deserialize, detectRuntime, discoverClasses, discoverFactories, discoverJobs, discoverListeners, discoverPolicies, dispatch, dispatchRoute, dispatchSync, encodePayload, encrypt, enumValues, env, errorBagFrom, errors, escapeHtml, event, exceedsJsonDepth, expandWildcardKeys, extensionFromMime, facade, fake, filterRouteList, formatAddress, formatDate, formatDateTime, formatRouteList, formatTimestamp, fromEntries, generateAppKey, generateModelTypes, getMorphAlias, getMorphedModel, guessTable, hashInfo, healthResponse, inertia, inertiaBody, inertiaHead, inject, ipMatches, isBlank, isBun, isDateCast, isEmptyValue, isEquivalent, isJsonCast, isListenerClass, isListenerTuple, isModel, isQueueable, isQueueableListener, isUnique, isUploadedFileLike, joinDiskPath, keyGenerateHandler, loadRelations, loadRoutesFrom, logger, makeFailedJobProvider, meetsLevel, mergeGroup, mergeLogContext, mergeRecursive, migrationDatePrefix, minimalPage, modelEventName, morphMap, normalizeAddress, normalizeAddresses, normalizeBackoff, normalizeLists, normalizePath, normalizeUri, now, old, openSqlite, optionalCookieJar, optionalSession, orderForBindings, parseArgv, parseBracketKey, parseCookieHeader, parseDateTime, parseKey, parseParameters, parseRuleSpec, parseSignature, passwordVerify, prepareValue, queueConfigDefaults, queueOptionsOf, raw as rawSql, rawWithBindings, redirect, registerHttpCommands, registerKeyGenerateCommand, registerMigrationCommands, registerModelTypesCommand, registerQueueCommands, registerStorageLinkCommand, renderContent, renderError, request, requestScope, resolveArguments, resolveDiskPath, resolveMiddleware, resolveMorphClass, resolveOptions, resourceRoutes, response, restoreJob, restoreValue, retry, roundTrip, route, routeListRows, runConsole, runConsoleAndExit, runMiddleware, runSeeder, sanitize, sendEmailVerificationUsing, sendNotification, serialize, serializeContext, serializeCookie, serializeDate, serializeValue, serve, serveBun, serveNode, servePublicFile, session, setClientAddress, stackFrames, statusFor, statusText, storageLinkHandler, substituteBindings, suggest, summarizeValidation, tap, toNotifiableList, toResponse, toWebRequest, tokenableType, transformLeaves, url, usePaginationResolvers, validateRequiredArguments, value, vite, viteReactRefresh, withHeaders, workerOptionsFrom, writeResponse };