@orieljs/framework 0.1.0-alpha.0

package/dist/contracts.d.ts

@@ -0,0 +1,1117 @@
+/** A typed, runtime-unique key for container bindings. */
+interface Token<T> {
+    readonly id: symbol;
+    readonly description: string;
+    /** Phantom field: only carries T at the type level. Never set at runtime. */
+    readonly __type?: T;
+}
+declare function token<T>(description: string): Token<T>;
+type Class<T> = abstract new (...args: any[]) => T;
+type Abstract<T> = Token<T> | Class<T>;
+type Factory<T> = (container: Container) => T;
+type Concrete<T> = Factory<T> | (new () => T);
+interface Container {
+    /** New instance on every make(). A class with no concrete binds to itself (constructed with no args). Root only; throws on a scope. */
+    bind<T>(abstract: Abstract<T>, concrete?: Concrete<T>): void;
+    /** One instance for the life of this container and its scopes. Root only; throws on a scope. */
+    singleton<T>(abstract: Abstract<T>, concrete?: Concrete<T>): void;
+    /** One instance per scope (e.g. per HTTP request or queue job). Root only; throws on a scope. */
+    scoped<T>(abstract: Abstract<T>, concrete?: Concrete<T>): void;
+    /** Register an existing object as a shared instance. Returns it. On a scope it stays local to that scope. */
+    instance<T>(abstract: Abstract<T>, instance: T): T;
+    /** Resolve. Unbound classes are constructed with `new Class()`. Unbound tokens throw BindingResolutionError. */
+    make<T>(abstract: Abstract<T>): T;
+    bound(abstract: Abstract<unknown>): boolean;
+    resolved(abstract: Abstract<unknown>): boolean;
+    /** Decorate or replace an instance each time it's resolved (applied before resolving callbacks). Root only; throws on a scope. */
+    extend<T>(abstract: Abstract<T>, extender: (instance: T, container: Container) => T): void;
+    /** Called after each resolution of the abstract. Root only; throws on a scope. */
+    resolving<T>(abstract: Abstract<T>, callback: (instance: T, container: Container) => void): void;
+    forgetInstance(abstract: Abstract<unknown>): void;
+    /** A child container: shares bindings and singletons with its parent, and has its own scoped instances. Bindings can't be registered on it. */
+    createScope(): Container;
+    /** Run fn with this container as the "current" one for inject(), helpers and facades (AsyncLocalStorage). */
+    run<R>(fn: () => R): R;
+}
+declare const Container: Token<Container>;
+
+interface ServiceProvider {
+    /** Bind things into the container. Synchronous. Don't resolve other services here. */
+    register?(): void;
+    /** Runs after every provider is registered. May be async (e.g. importing route files). */
+    boot?(): void | Promise<void>;
+}
+type ServiceProviderClass = new (app: Application) => ServiceProvider;
+interface Application extends Container {
+    readonly version: string;
+    basePath(path?: string): string;
+    appPath(path?: string): string;
+    bootstrapPath(path?: string): string;
+    configPath(path?: string): string;
+    databasePath(path?: string): string;
+    publicPath(path?: string): string;
+    resourcePath(path?: string): string;
+    storagePath(path?: string): string;
+    /** With no args returns the environment name. With args returns whether it matches any of them. */
+    environment(): string;
+    environment(...environments: string[]): boolean;
+    isProduction(): boolean;
+    isLocal(): boolean;
+    runningInConsole(): boolean;
+    /** Mark the app as running in the console (the CLI entry point calls this). Defaults to true. */
+    setRunningInConsole(value?: boolean): void;
+    runningUnitTests(): boolean;
+    /** Registers the provider. If the app is already booted, the provider is booted immediately. */
+    register(provider: ServiceProvider | ServiceProviderClass): Promise<ServiceProvider>;
+    getProviders(): ServiceProvider[];
+    boot(): Promise<void>;
+    isBooted(): boolean;
+    booting(callback: (app: Application) => void | Promise<void>): void;
+    booted(callback: (app: Application) => void | Promise<void>): void;
+    /** Handle one HTTP request in a fresh request scope via the bound HttpKernel. */
+    handle(request: Request): Promise<Response>;
+    /** Register a callback that terminate() runs, in registration order. */
+    terminating(callback: () => void | Promise<void>): void;
+    terminate(): Promise<void>;
+}
+declare const Application: Token<Application>;
+interface ExceptionHandler {
+    report(error: unknown): Promise<void>;
+    shouldReport(error: unknown): boolean;
+    /** `request` is the scoped HttpRequest (Contracts/Http) when available, else the raw Request. */
+    render(request: unknown, error: unknown): Promise<Response>;
+}
+declare const ExceptionHandler: Token<ExceptionHandler>;
+/** Paths passed to Application.configure().withRouting(). Routing (Wave 1) loads them. */
+interface RoutingPaths {
+    web?: string;
+    api?: string;
+    console?: string;
+    health?: string;
+    apiPrefix: string;
+}
+declare const RoutingPaths: Token<RoutingPaths>;
+/** The object passed to Application.configure().withExceptions(e => …), like Laravel's Exceptions class. */
+interface ExceptionsConfigurator {
+    /** Custom reporting. Return false to stop the default logging. */
+    report(callback: (error: unknown) => void | boolean | Promise<void | boolean>): this;
+    /** Custom rendering. Return undefined to fall through to the default rendering. */
+    render(callback: (error: unknown, request: unknown) => Response | undefined | Promise<Response | undefined>): this;
+    /** Never report errors of these classes. */
+    dontReport(...classes: Array<abstract new (...args: never[]) => Error>): this;
+}
+/** Callbacks collected by withMiddleware()/withExceptions(); invoked by Http / the exception handler (Wave 1). */
+type ConfigCallbacks<T> = Array<(configurator: T) => void>;
+/** Typed as unknown here because MiddlewareConfigurator lives in Contracts/Http; Http casts on use. */
+declare const MiddlewareCallbacks: Token<ConfigCallbacks<unknown>>;
+declare const ExceptionCallbacks: Token<ConfigCallbacks<ExceptionsConfigurator>>;
+
+interface ConfigRepository {
+    has(key: string): boolean;
+    /** Dot notation: get('database.connections.sqlite.database'). */
+    get<T = unknown>(key: string, defaultValue?: T): T;
+    set(key: string, value: unknown): void;
+    set(values: Record<string, unknown>): void;
+    push(key: string, value: unknown): void;
+    all(): Record<string, unknown>;
+}
+declare const ConfigRepository: Token<ConfigRepository>;
+
+interface Arrayable<T = unknown> {
+    toArray(): T;
+}
+interface Jsonable {
+    toJson(): string;
+}
+interface Htmlable {
+    toHtml(): string;
+}
+/** Anything a controller can return that knows how to become a Response. */
+interface Responsable {
+    toResponse(request: unknown): Response | Promise<Response>;
+}
+/** The minimal collection surface contracts rely on (implemented by @orieljs/collections). */
+interface Enumerable<T> extends Iterable<T>, Arrayable<unknown[]> {
+    all(): T[];
+    count(): number;
+    isEmpty(): boolean;
+}
+interface ClassRegistry {
+    /** Registers under `name` (default: cls.name). Throws if the name is already taken by a different class. */
+    register(cls: Class<unknown>, name?: string): string;
+    nameOf(cls: Class<unknown>): string | undefined;
+    resolve<T = unknown>(name: string): Class<T>;
+    has(name: string): boolean;
+}
+declare const ClassRegistry: Token<ClassRegistry>;
+
+type PipeNext<T> = (passable: T) => Promise<unknown>;
+type PipeClosure<T> = (passable: T, next: PipeNext<T>) => Promise<unknown> | unknown;
+/** A class resolved from the container whose `via` method (default 'handle') is called; or a string alias 'name:param1,param2'. */
+type Pipe<T> = PipeClosure<T> | Class<object> | string;
+interface Pipeline<T = unknown> {
+    send(passable: T): this;
+    through(pipes: ReadonlyArray<Pipe<T>>): this;
+    pipe(...pipes: Array<Pipe<T>>): this;
+    /** Method called on class pipes. Default 'handle'. */
+    via(method: string): this;
+    then<R>(destination: (passable: T) => R | Promise<R>): Promise<R>;
+    thenReturn(): Promise<T>;
+}
+interface PipelineFactory {
+    make<T>(): Pipeline<T>;
+}
+declare const PipelineFactory: Token<PipelineFactory>;
+
+/** The session of the current request (scoped). Loaded and saved by the StartSession middleware. */
+interface Session {
+    getId(): string;
+    start(): Promise<void>;
+    save(): Promise<void>;
+    all(): Record<string, unknown>;
+    has(key: string): boolean;
+    get<T = unknown>(key: string, defaultValue?: T): T;
+    put(key: string | Record<string, unknown>, value?: unknown): void;
+    push(key: string, value: unknown): void;
+    pull<T = unknown>(key: string, defaultValue?: T): T;
+    forget(...keys: string[]): void;
+    flush(): void;
+    flash(key: string, value: unknown): void;
+    now(key: string, value: unknown): void;
+    reflash(): void;
+    keep(...keys: string[]): void;
+    getOldInput<T = unknown>(key?: string, defaultValue?: T): T;
+    flashInput(input: Record<string, unknown>): void;
+    token(): string;
+    regenerateToken(): void;
+    regenerate(destroy?: boolean): Promise<void>;
+    invalidate(): Promise<void>;
+    previousUrl(): string | undefined;
+    setPreviousUrl(url: string): void;
+}
+declare const Session: Token<Session>;
+/** Storage driver (file, cookie, database, redis). */
+interface SessionHandler {
+    read(id: string): Promise<string>;
+    write(id: string, data: string): Promise<void>;
+    destroy(id: string): Promise<void>;
+    gc(maxLifetimeSeconds: number): Promise<void>;
+}
+
+/** Web-standard body/headers init types, derived from the runtime's global Response/Headers (no DOM lib needed). */
+type BodyInit = ConstructorParameters<typeof Response>[0];
+type HeadersInit = ConstructorParameters<typeof Headers>[0];
+interface UploadedFile {
+    readonly clientName: string;
+    readonly mimeType: string;
+    readonly size: number;
+    extension(): string;
+    arrayBuffer(): Promise<ArrayBuffer>;
+    /** Stores on a Filesystem disk. Returns the stored path. */
+    store(directory: string, disk?: string): Promise<string>;
+    storeAs(directory: string, name: string, disk?: string): Promise<string>;
+}
+/**
+ * Oriel's request wrapper (one per request, scoped).
+ * The Http kernel awaits `load()` before any middleware runs, so every input accessor below is synchronous.
+ */
+interface HttpRequest {
+    readonly raw: Request;
+    load(): Promise<this>;
+    method(): string;
+    isMethod(method: string): boolean;
+    url(): string;
+    fullUrl(): string;
+    path(): string;
+    is(...patterns: string[]): boolean;
+    routeIs(...names: string[]): boolean;
+    header(name: string): string | undefined;
+    header(name: string, defaultValue: string): string;
+    bearerToken(): string | undefined;
+    ip(): string | undefined;
+    expectsJson(): boolean;
+    ajax(): boolean;
+    query<T = unknown>(key?: string, defaultValue?: T): T;
+    input<T = unknown>(key?: string, defaultValue?: T): T;
+    all(): Record<string, unknown>;
+    only(...keys: string[]): Record<string, unknown>;
+    except(...keys: string[]): Record<string, unknown>;
+    has(...keys: string[]): boolean;
+    filled(key: string): boolean;
+    boolean(key: string, defaultValue?: boolean): boolean;
+    integer(key: string, defaultValue?: number): number;
+    merge(values: Record<string, unknown>): this;
+    file(key: string): UploadedFile | undefined;
+    cookie(name: string): string | undefined;
+    /** Route parameter (after model binding), or every parameter when called with no key. */
+    route<T = unknown>(key?: string): T;
+    session(): Session;
+    /** The user resolved earlier by auth middleware. Undefined for guests. Use `await Auth.user()` to resolve lazily. */
+    user<T = unknown>(guard?: string): T | undefined;
+    setUserResolver(resolver: (guard?: string) => unknown): void;
+}
+declare const HttpRequest: Token<HttpRequest>;
+type Next = (request: HttpRequest) => Promise<Response>;
+interface Middleware {
+    handle(request: HttpRequest, next: Next, ...parameters: string[]): Promise<Response>;
+    terminate?(request: HttpRequest, response: Response): Promise<void>;
+}
+type MiddlewareClass = new (...args: any[]) => Middleware;
+/** The object passed to Application.configure().withMiddleware(m => …), like Laravel's Middleware class. */
+interface MiddlewareConfigurator {
+    append(...middleware: MiddlewareClass[]): this;
+    prepend(...middleware: MiddlewareClass[]): this;
+    web(options: {
+        append?: MiddlewareClass[];
+        prepend?: MiddlewareClass[];
+        remove?: MiddlewareClass[];
+    }): this;
+    api(options: {
+        append?: MiddlewareClass[];
+        prepend?: MiddlewareClass[];
+        remove?: MiddlewareClass[];
+    }): this;
+    alias(aliases: Record<string, MiddlewareClass>): this;
+    group(name: string, middleware: Array<MiddlewareClass | string>): this;
+    validateCsrfTokens(options: {
+        except: string[];
+    }): this;
+    redirectGuestsTo(url: string | ((request: HttpRequest) => string)): this;
+}
+interface HttpKernel {
+    handle(request: Request): Promise<Response>;
+    terminate?(request: Request, response: Response): Promise<void>;
+}
+declare const HttpKernel: Token<HttpKernel>;
+interface ResponseFactory {
+    make(content?: BodyInit | null, status?: number, headers?: HeadersInit): Response;
+    json(data: unknown, status?: number, headers?: HeadersInit): Response;
+    noContent(status?: number): Response;
+    download(path: string, name?: string, headers?: HeadersInit): Promise<Response>;
+    stream(body: ReadableStream, status?: number, headers?: HeadersInit): Response;
+}
+declare const ResponseFactory: Token<ResponseFactory>;
+
+/** Public method names of a controller (excludes non-function members). */
+type ActionMethods<C> = {
+    [K in keyof C]: C[K] extends (...args: any[]) => unknown ? K : never;
+}[keyof C] & string;
+type ControllerAction<C> = readonly [Class<C>, ActionMethods<C>];
+type RouteClosure = (...args: any[]) => unknown;
+type RouteAction = RouteClosure | ControllerAction<any>;
+type MiddlewareReference = string | MiddlewareClass;
+interface Route {
+    readonly methods: readonly string[];
+    readonly uri: string;
+    getName(): string | undefined;
+    name(name: string): this;
+    middleware(...middleware: MiddlewareReference[]): this;
+    withoutMiddleware(...middleware: MiddlewareReference[]): this;
+    where(parameter: string, pattern: string): this;
+    where(patterns: Record<string, string>): this;
+}
+interface RouteRegistrar {
+    prefix(prefix: string): RouteRegistrar;
+    name(prefix: string): RouteRegistrar;
+    middleware(...middleware: MiddlewareReference[]): RouteRegistrar;
+    controller(controller: Class<unknown>): RouteRegistrar;
+    group(routes: () => void | Promise<void>): Promise<void>;
+}
+interface ResourceOptions {
+    only?: string[];
+    except?: string[];
+    parameters?: Record<string, string>;
+    names?: Record<string, string>;
+}
+interface Router {
+    get<C>(uri: string, action: ControllerAction<C> | RouteClosure): Route;
+    post<C>(uri: string, action: ControllerAction<C> | RouteClosure): Route;
+    put<C>(uri: string, action: ControllerAction<C> | RouteClosure): Route;
+    patch<C>(uri: string, action: ControllerAction<C> | RouteClosure): Route;
+    delete<C>(uri: string, action: ControllerAction<C> | RouteClosure): Route;
+    options<C>(uri: string, action: ControllerAction<C> | RouteClosure): Route;
+    any<C>(uri: string, action: ControllerAction<C> | RouteClosure): Route;
+    match<C>(methods: string[], uri: string, action: ControllerAction<C> | RouteClosure): Route;
+    redirect(from: string, to: string, status?: number): Route;
+    view(uri: string, view: string, data?: Record<string, unknown>): Route;
+    resource(name: string, controller: Class<unknown>, options?: ResourceOptions): void;
+    apiResource(name: string, controller: Class<unknown>, options?: ResourceOptions): void;
+    fallback(action: RouteAction): Route;
+    prefix(prefix: string): RouteRegistrar;
+    name(prefix: string): RouteRegistrar;
+    middleware(...middleware: MiddlewareReference[]): RouteRegistrar;
+    controller(controller: Class<unknown>): RouteRegistrar;
+    /** Explicit model binding: Route.model('author', User). */
+    model(parameter: string, model: Class<unknown>): void;
+    /** Custom binding resolver. */
+    bind(parameter: string, resolver: (value: string) => unknown | Promise<unknown>): void;
+    pattern(parameter: string, pattern: string): void;
+    getRoutes(): readonly Route[];
+    current(): Route | undefined;
+}
+declare const Router: Token<Router>;
+/**
+ * Resolves implicit route-model bindings by naming convention ({post} → Post).
+ * Bound by Database (Wave 1) so that Routing never imports Database.
+ * Returns undefined when no model matches the parameter name. Throws ModelNotFound when the model exists but the row doesn't.
+ */
+interface RouteModelResolver {
+    resolve(parameter: string, value: string, field?: string): Promise<unknown | undefined>;
+    resolveExplicit(model: Class<unknown>, value: string, field?: string): Promise<unknown>;
+}
+declare const RouteModelResolver: Token<RouteModelResolver>;
+interface UrlGenerator {
+    to(path: string, query?: Record<string, unknown>, absolute?: boolean): string;
+    route(name: string, parameters?: unknown, absolute?: boolean): string;
+    asset(path: string): string;
+    current(): string;
+    previous(fallback?: string): string;
+    hasRoute(name: string): boolean;
+}
+declare const UrlGenerator: Token<UrlGenerator>;
+interface RedirectResponse extends Responsable {
+    readonly targetUrl: string;
+    with(key: string | Record<string, unknown>, value?: unknown): this;
+    withErrors(errors: Record<string, string | string[]>, bag?: string): this;
+    withInput(input?: Record<string, unknown>): this;
+    withCookie(name: string, value: string, minutes?: number): this;
+}
+interface Redirector {
+    to(path: string, status?: number): RedirectResponse;
+    route(name: string, parameters?: unknown, status?: number): RedirectResponse;
+    back(fallback?: string, status?: number): RedirectResponse;
+    intended(fallback?: string): RedirectResponse;
+    away(url: string, status?: number): RedirectResponse;
+}
+declare const Redirector: Token<Redirector>;
+
+interface Cookie {
+    name: string;
+    value: string;
+    /** Minutes until expiry. 0 = session cookie, negative = delete. */
+    minutes: number;
+    path: string;
+    domain?: string;
+    secure: boolean;
+    httpOnly: boolean;
+    sameSite: 'lax' | 'strict' | 'none';
+}
+interface CookieJar {
+    make(name: string, value: string, minutes?: number, options?: Partial<Omit<Cookie, 'name' | 'value' | 'minutes'>>): Cookie;
+    forever(name: string, value: string): Cookie;
+    forget(name: string): Cookie;
+    /** Queue a cookie to attach to the outgoing response (scoped per request). */
+    queue(cookie: Cookie): void;
+    queued(): Cookie[];
+}
+declare const CookieJar: Token<CookieJar>;
+
+interface Encrypter {
+    /** JSON-serializes unless serialize=false (then value must be a string). AES-256-GCM, keyed by APP_KEY. */
+    encrypt(value: unknown, serialize?: boolean): string;
+    decrypt<T = unknown>(payload: string, unserialize?: boolean): T;
+    encryptString(value: string): string;
+    decryptString(payload: string): string;
+    getKey(): Uint8Array;
+}
+declare const Encrypter: Token<Encrypter>;
+
+interface Hasher {
+    make(value: string): Promise<string>;
+    check(value: string, hashed: string): Promise<boolean>;
+    needsRehash(hashed: string): boolean;
+    info(hashed: string): {
+        algorithm: string;
+        options: Record<string, unknown>;
+    };
+}
+declare const Hasher: Token<Hasher>;
+
+interface View extends Htmlable {
+    readonly name: string;
+    with(key: string | Record<string, unknown>, value?: unknown): this;
+    render(): Promise<string>;
+}
+/** Resolves 'posts.index' → resources/views/posts/index.tsx and renders it to HTML on the server. */
+interface ViewFactory {
+    make(name: string, data?: Record<string, unknown>): View;
+    exists(name: string): boolean;
+    share(key: string | Record<string, unknown>, value?: unknown): void;
+    composer(views: string | string[], composer: (view: View) => void | Promise<void>): void;
+}
+declare const ViewFactory: Token<ViewFactory>;
+
+type LogLevel = 'emergency' | 'alert' | 'critical' | 'error' | 'warning' | 'notice' | 'info' | 'debug';
+interface Logger {
+    log(level: LogLevel, message: string, context?: Record<string, unknown>): void;
+    emergency(message: string, context?: Record<string, unknown>): void;
+    alert(message: string, context?: Record<string, unknown>): void;
+    critical(message: string, context?: Record<string, unknown>): void;
+    error(message: string, context?: Record<string, unknown>): void;
+    warning(message: string, context?: Record<string, unknown>): void;
+    notice(message: string, context?: Record<string, unknown>): void;
+    info(message: string, context?: Record<string, unknown>): void;
+    debug(message: string, context?: Record<string, unknown>): void;
+    /** Adds context to every later log entry in the current scope (request or job). */
+    withContext(context: Record<string, unknown>): this;
+}
+interface LogManager extends Logger {
+    channel(name?: string): Logger;
+    stack(channels: string[]): Logger;
+}
+declare const LogManager: Token<LogManager>;
+
+type ErrorKind = 'Http' | 'ModelNotFound' | 'Validation' | 'Authentication' | 'Authorization' | 'TokenMismatch' | 'BindingResolution' | 'CircularDependency' | 'ContainerNotAvailable';
+/** Every error thrown by the framework implements this. The exception handler switches on `kind`. */
+interface OrielError extends Error {
+    readonly kind: ErrorKind;
+    /** HTTP status the error should render as, when relevant. */
+    readonly status?: number;
+    readonly headers?: Record<string, string>;
+}
+interface ValidationError extends OrielError {
+    readonly kind: 'Validation';
+    readonly errors: Record<string, string[]>;
+    readonly errorBag: string;
+    /** Where to redirect for non-JSON requests (defaults to back()). */
+    readonly redirectTo?: string;
+}
+interface AuthenticationError extends OrielError {
+    readonly kind: 'Authentication';
+    readonly guards: string[];
+    readonly redirectTo?: string;
+}
+interface ModelNotFoundError extends OrielError {
+    readonly kind: 'ModelNotFound';
+    readonly model: string;
+    readonly ids: unknown[];
+}
+
+type Operator = '=' | '!=' | '<>' | '<' | '<=' | '>' | '>=' | 'like' | 'not like' | 'ilike' | 'in' | 'not in';
+type Row = Record<string, unknown>;
+/** The minimal query surface other components rely on (Queue, Cache, Session, Validation, Notifications). */
+interface QueryBuilder<T = Row> {
+    select(...columns: string[]): this;
+    where(column: string, value: unknown): this;
+    where(column: string, operator: Operator, value: unknown): this;
+    where(conditions: Row): this;
+    orWhere(column: string, value: unknown): this;
+    orWhere(column: string, operator: Operator, value: unknown): this;
+    whereIn(column: string, values: readonly unknown[]): this;
+    whereNotIn(column: string, values: readonly unknown[]): this;
+    whereNull(column: string): this;
+    whereNotNull(column: string): this;
+    orderBy(column: string, direction?: 'asc' | 'desc'): this;
+    limit(count: number): this;
+    offset(count: number): this;
+    lockForUpdate(): this;
+    get(): Promise<Enumerable<T>>;
+    first(): Promise<T | undefined>;
+    find(id: unknown): Promise<T | undefined>;
+    value<V = unknown>(column: string): Promise<V | undefined>;
+    pluck<V = unknown>(column: string): Promise<Enumerable<V>>;
+    count(): Promise<number>;
+    exists(): Promise<boolean>;
+    insert(values: Row | Row[]): Promise<void>;
+    insertGetId(values: Row, keyName?: string): Promise<number | string>;
+    update(values: Row): Promise<number>;
+    upsert(values: Row | Row[], uniqueBy: string[], update?: string[]): Promise<number>;
+    increment(column: string, amount?: number, extra?: Row): Promise<number>;
+    decrement(column: string, amount?: number, extra?: Row): Promise<number>;
+    delete(): Promise<number>;
+}
+type DriverName = 'pgsql' | 'mysql' | 'sqlite';
+interface DatabaseConnection {
+    getName(): string;
+    getDriverName(): DriverName;
+    table<T = Row>(table: string): QueryBuilder<T>;
+    select<T = Row>(sql: string, bindings?: readonly unknown[]): Promise<T[]>;
+    statement(sql: string, bindings?: readonly unknown[]): Promise<void>;
+    /** Nested calls use savepoints. Rolls back if fn throws. */
+    transaction<R>(fn: (connection: DatabaseConnection) => Promise<R>): Promise<R>;
+}
+interface DatabaseManager extends DatabaseConnection {
+    connection(name?: string): DatabaseConnection;
+    disconnect(name?: string): Promise<void>;
+}
+declare const DatabaseManager: Token<DatabaseManager>;
+/** What non-Database components may rely on from a model instance. */
+interface ModelInstance {
+    exists: boolean;
+    getKey(): unknown;
+    getKeyName(): string;
+    getTable(): string;
+    getRouteKey(): unknown;
+    getRouteKeyName(): string;
+    getAttribute<T = unknown>(key: string): T;
+    setAttribute(key: string, value: unknown): this;
+    fill(attributes: Row): this;
+    save(): Promise<boolean>;
+    delete(): Promise<boolean>;
+    refresh(): Promise<this>;
+    toArray(): Row;
+    toJSON(): Row;
+}
+interface ModelStatic<M extends ModelInstance = ModelInstance> {
+    new (): M;
+    query(): QueryBuilder<M>;
+    find(id: unknown): Promise<M | undefined>;
+    findOrFail(id: unknown): Promise<M>;
+}
+
+/** A rule object (Laravel's ValidationRule). Call fail() to reject the value. */
+interface ValidationRule {
+    validate(attribute: string, value: unknown, fail: (message: string) => void, data: Record<string, unknown>): void | Promise<void>;
+}
+/** 'required|string|max:255', or an array mixing strings and rule objects. Keys support dot + `*` wildcards. */
+type Rules = Record<string, string | ReadonlyArray<string | ValidationRule>>;
+interface MessageBag {
+    has(key: string): boolean;
+    first(key?: string): string | undefined;
+    get(key: string): string[];
+    all(): string[];
+    isEmpty(): boolean;
+    count(): number;
+    toObject(): Record<string, string[]>;
+}
+interface Validator {
+    passes(): Promise<boolean>;
+    fails(): Promise<boolean>;
+    /** Only the keys that have rules. Throws ValidationError (Exceptions.ts) on failure. */
+    validated<T = Record<string, unknown>>(): Promise<T>;
+    /** Valid only after passes()/fails()/validated() has run. */
+    errors(): MessageBag;
+    after(callback: (validator: Validator) => void | Promise<void>): this;
+}
+type RuleCallback = (attribute: string, value: unknown, parameters: string[], data: Record<string, unknown>) => boolean | Promise<boolean>;
+interface ValidationFactory {
+    make(data: Record<string, unknown>, rules: Rules, messages?: Record<string, string>, attributes?: Record<string, string>): Validator;
+    /** Registers a string rule, e.g. extend('uppercase', fn, ':attribute must be uppercase'). */
+    extend(name: string, callback: RuleCallback, message?: string): void;
+}
+declare const ValidationFactory: Token<ValidationFactory>;
+
+interface Authenticatable {
+    getAuthIdentifierName(): string;
+    getAuthIdentifier(): unknown;
+    getAuthPassword(): string;
+    getRememberToken(): string | undefined;
+    setRememberToken(value: string): void;
+    getRememberTokenName(): string;
+}
+type Credentials = Record<string, unknown>;
+interface UserProvider {
+    retrieveById(id: unknown): Promise<Authenticatable | undefined>;
+    retrieveByToken(id: unknown, token: string): Promise<Authenticatable | undefined>;
+    updateRememberToken(user: Authenticatable, token: string): Promise<void>;
+    retrieveByCredentials(credentials: Credentials): Promise<Authenticatable | undefined>;
+    validateCredentials(user: Authenticatable, credentials: Credentials): Promise<boolean>;
+}
+interface Guard {
+    check(): Promise<boolean>;
+    guest(): Promise<boolean>;
+    user<T extends Authenticatable = Authenticatable>(): Promise<T | undefined>;
+    id(): Promise<unknown>;
+    validate(credentials: Credentials): Promise<boolean>;
+    hasUser(): boolean;
+    setUser(user: Authenticatable): void;
+}
+interface StatefulGuard extends Guard {
+    attempt(credentials: Credentials, remember?: boolean): Promise<boolean>;
+    once(credentials: Credentials): Promise<boolean>;
+    login(user: Authenticatable, remember?: boolean): Promise<void>;
+    loginUsingId(id: unknown, remember?: boolean): Promise<Authenticatable | false>;
+    logout(): Promise<void>;
+}
+interface AuthFactory {
+    guard(name?: string): StatefulGuard | Guard;
+    shouldUse(name: string): void;
+    extend(driver: string, factory: (name: string, config: Record<string, unknown>) => Guard): void;
+    provider(driver: string, factory: (config: Record<string, unknown>) => UserProvider): void;
+}
+declare const AuthFactory: Token<AuthFactory>;
+type AbilityCallback = (user: Authenticatable | undefined, ...args: unknown[]) => boolean | Promise<boolean>;
+interface Gate {
+    define(ability: string, callback: AbilityCallback): this;
+    policy(model: Class<unknown>, policy: Class<unknown>): this;
+    before(callback: (user: Authenticatable | undefined, ability: string) => boolean | undefined | Promise<boolean | undefined>): this;
+    allows(ability: string, ...args: unknown[]): Promise<boolean>;
+    denies(ability: string, ...args: unknown[]): Promise<boolean>;
+    /** Throws an Authorization OrielError (403) when denied. */
+    authorize(ability: string, ...args: unknown[]): Promise<void>;
+    any(abilities: string[], ...args: unknown[]): Promise<boolean>;
+    forUser(user: Authenticatable | undefined): Gate;
+}
+declare const Gate: Token<Gate>;
+type PasswordStatus = 'passwords.sent' | 'passwords.reset' | 'passwords.user' | 'passwords.token' | 'passwords.throttled';
+interface PasswordBroker {
+    sendResetLink(credentials: Credentials): Promise<PasswordStatus>;
+    reset(credentials: Credentials, callback: (user: Authenticatable, password: string) => Promise<void>): Promise<PasswordStatus>;
+}
+declare const PasswordBroker: Token<PasswordBroker>;
+interface MustVerifyEmail {
+    hasVerifiedEmail(): boolean;
+    markEmailAsVerified(): Promise<boolean>;
+    sendEmailVerificationNotification(): Promise<void>;
+    getEmailForVerification(): string;
+}
+
+/** Options a job class may declare as public fields. Their presence (or implementing ShouldQueue) makes things queueable. */
+interface ShouldQueue {
+    connection?: string;
+    queue?: string;
+    /** Seconds. */
+    delay?: number;
+    tries?: number;
+    /** Seconds, or a per-attempt list. */
+    backoff?: number | number[];
+    /** Seconds. */
+    timeout?: number;
+    uniqueId?(): string;
+}
+/** A job: public fields are its serialized data; handle() runs on the worker (inject() works inside it). */
+interface Job extends Partial<ShouldQueue> {
+    handle(): unknown | Promise<unknown>;
+    failed?(error: unknown): void | Promise<void>;
+}
+interface QueuePayload {
+    uuid: string;
+    /** ClassRegistry name. */
+    job: string;
+    displayName: string;
+    data: Record<string, unknown>;
+    attempts: number;
+    maxTries?: number;
+    backoff?: number[];
+    timeout?: number;
+    /** Unix ms. */
+    pushedAt: number;
+    batchId?: string;
+    chain?: QueuePayload[];
+}
+interface QueueJob {
+    getJobId(): string;
+    getQueue(): string;
+    payload(): QueuePayload;
+    attempts(): number;
+    delete(): Promise<void>;
+    release(delaySeconds?: number): Promise<void>;
+    /** Marks as failed: stores it via FailedJobProvider and calls job.failed(). */
+    fail(error: unknown): Promise<void>;
+    isDeleted(): boolean;
+    isReleased(): boolean;
+}
+interface Queue {
+    push(job: Job, queue?: string): Promise<string>;
+    later(delaySeconds: number, job: Job, queue?: string): Promise<string>;
+    pushRaw(payload: QueuePayload, queue?: string, delaySeconds?: number): Promise<string>;
+    pop(queue?: string): Promise<QueueJob | undefined>;
+    size(queue?: string): Promise<number>;
+    clear(queue?: string): Promise<number>;
+}
+interface QueueManager extends Queue {
+    connection(name?: string): Queue;
+    extend(driver: string, factory: (config: Record<string, unknown>) => Queue): void;
+}
+declare const QueueManager: Token<QueueManager>;
+interface FailedJob {
+    id: string;
+    connection: string;
+    queue: string;
+    payload: QueuePayload;
+    exception: string;
+    failedAt: Date;
+}
+interface FailedJobProvider {
+    log(connection: string, queue: string, payload: QueuePayload, error: unknown): Promise<string>;
+    all(): Promise<FailedJob[]>;
+    find(id: string): Promise<FailedJob | undefined>;
+    forget(id: string): Promise<boolean>;
+    flush(): Promise<void>;
+}
+declare const FailedJobProvider: Token<FailedJobProvider>;
+
+interface Batch {
+    readonly id: string;
+    readonly name: string;
+    readonly totalJobs: number;
+    readonly pendingJobs: number;
+    readonly failedJobs: number;
+    progress(): number;
+    finished(): boolean;
+    cancelled(): boolean;
+    cancel(): Promise<void>;
+}
+interface PendingChain {
+    onConnection(connection: string): this;
+    onQueue(queue: string): this;
+    /** Runs as a job if any job in the chain fails. Callbacks are jobs, because closures can't be serialized. */
+    catch(job: Job): this;
+    dispatch(): Promise<void>;
+}
+interface PendingBatch {
+    name(name: string): this;
+    onConnection(connection: string): this;
+    onQueue(queue: string): this;
+    allowFailures(allow?: boolean): this;
+    then(job: Job): this;
+    catch(job: Job): this;
+    finally(job: Job): this;
+    dispatch(): Promise<Batch>;
+}
+interface BusDispatcher {
+    /** Queues it when the job is queueable (implements ShouldQueue / declares queue options), otherwise runs it now. */
+    dispatch(job: Job): Promise<unknown>;
+    dispatchSync(job: Job): Promise<unknown>;
+    /** Runs after the current response is sent (or the current job finishes). */
+    dispatchAfterResponse(job: Job): void;
+    chain(jobs: Job[]): PendingChain;
+    batch(jobs: Job[]): PendingBatch;
+    findBatch(id: string): Promise<Batch | undefined>;
+}
+declare const BusDispatcher: Token<BusDispatcher>;
+
+/** A CLI command. Signature uses Laravel syntax: 'mail:send {user} {--queue=default}'. */
+interface Command {
+    readonly signature: string;
+    readonly description: string;
+    handle(): number | void | Promise<number | void>;
+}
+interface ConsoleKernel {
+    /** Returns the exit code. */
+    handle(argv: string[]): Promise<number>;
+    call(command: string, parameters?: Record<string, unknown>): Promise<number>;
+    /** Output buffered from the last call(). */
+    output(): string;
+    all(): Record<string, Command>;
+}
+declare const ConsoleKernel: Token<ConsoleKernel>;
+interface ScheduledEvent {
+    readonly expression: string;
+    cron(expression: string): this;
+    everyMinute(): this;
+    everyFiveMinutes(): this;
+    everyFifteenMinutes(): this;
+    everyThirtyMinutes(): this;
+    hourly(): this;
+    hourlyAt(minute: number): this;
+    daily(): this;
+    dailyAt(time: string): this;
+    twiceDaily(first?: number, second?: number): this;
+    weekly(): this;
+    weeklyOn(day: number, time?: string): this;
+    monthly(): this;
+    monthlyOn(day: number, time?: string): this;
+    yearly(): this;
+    weekdays(): this;
+    weekends(): this;
+    timezone(timezone: string): this;
+    between(start: string, end: string): this;
+    when(callback: () => boolean | Promise<boolean>): this;
+    skip(callback: () => boolean | Promise<boolean>): this;
+    /** Uses a cache lock (default 1440 minutes). */
+    withoutOverlapping(expiresAtMinutes?: number): this;
+    /** Uses a cache lock so only one server runs it. */
+    onOneServer(): this;
+    runInBackground(): this;
+    name(name: string): this;
+    description(description: string): this;
+    isDue(now: Date): boolean;
+    run(): Promise<void>;
+}
+interface Schedule {
+    command(command: string, parameters?: string[]): ScheduledEvent;
+    job(job: Job, queue?: string, connection?: string): ScheduledEvent;
+    call(callback: () => unknown | Promise<unknown>): ScheduledEvent;
+    events(): ScheduledEvent[];
+    dueEvents(now: Date): ScheduledEvent[];
+}
+declare const Schedule: Token<Schedule>;
+
+interface Address {
+    address: string;
+    name?: string;
+}
+/** A plain email string, an Address, or anything with email (+ optional name), such as a User model. */
+type MailRecipient = string | Address | {
+    email: string;
+    name?: string;
+};
+interface Envelope {
+    from?: MailRecipient;
+    to?: MailRecipient[];
+    cc?: MailRecipient[];
+    bcc?: MailRecipient[];
+    replyTo?: MailRecipient[];
+    subject?: string;
+    tags?: string[];
+    metadata?: Record<string, string>;
+}
+interface Content {
+    /** A View name, rendered by ViewFactory (TSX). */
+    view?: string;
+    /** A plain-text view name. */
+    text?: string;
+    /** Raw HTML (used when no view is given). */
+    htmlString?: string;
+    with?: Record<string, unknown>;
+}
+interface Attachment {
+    name: string;
+    path?: string;
+    data?: Uint8Array | string;
+    mime?: string;
+}
+/** Laravel 10+ style mailable: envelope() + content() + attachments(). */
+interface Mailable {
+    envelope(): Envelope | Promise<Envelope>;
+    content(): Content | Promise<Content>;
+    attachments?(): Attachment[] | Promise<Attachment[]>;
+}
+/** Fully rendered message handed to a transport. */
+interface OutgoingMessage {
+    from: Address;
+    to: Address[];
+    cc: Address[];
+    bcc: Address[];
+    replyTo: Address[];
+    subject: string;
+    html?: string;
+    text?: string;
+    attachments: Attachment[];
+    headers: Record<string, string>;
+}
+interface SentMessage {
+    messageId: string;
+    message: OutgoingMessage;
+}
+interface MailTransport {
+    send(message: OutgoingMessage): Promise<SentMessage>;
+}
+interface PendingMail {
+    cc(recipients: MailRecipient | MailRecipient[]): this;
+    bcc(recipients: MailRecipient | MailRecipient[]): this;
+    send(mailable: Mailable): Promise<SentMessage | undefined>;
+    queue(mailable: Mailable): Promise<void>;
+    later(delaySeconds: number, mailable: Mailable): Promise<void>;
+}
+interface Mailer {
+    to(recipients: MailRecipient | MailRecipient[]): PendingMail;
+    /** Sends to the recipients given in the mailable's envelope. Queues it if the mailable is queueable. */
+    send(mailable: Mailable): Promise<SentMessage | undefined>;
+    queue(mailable: Mailable): Promise<void>;
+}
+interface MailManager extends Mailer {
+    mailer(name?: string): Mailer;
+    extend(transport: string, factory: (config: Record<string, unknown>) => MailTransport): void;
+}
+declare const MailManager: Token<MailManager>;
+
+interface Notifiable {
+    /** e.g. 'mail' → email address, 'database' → the model itself. */
+    routeNotificationFor(channel: string, notification: Notification): unknown;
+}
+interface Notification {
+    /** Optional id; set by the dispatcher when missing. */
+    id?: string;
+    via(notifiable: Notifiable): string[];
+    /** Returns a Mailable (Contracts/Mail) or the Notifications MailMessage builder. */
+    toMail?(notifiable: Notifiable): unknown;
+    toDatabase?(notifiable: Notifiable): Record<string, unknown>;
+    toArray?(notifiable: Notifiable): Record<string, unknown>;
+}
+interface NotificationChannel {
+    send(notifiable: Notifiable, notification: Notification): Promise<void>;
+}
+interface NotificationDispatcher {
+    /** Queues it when the notification is queueable, otherwise sends immediately. */
+    send(notifiables: Notifiable | Notifiable[], notification: Notification): Promise<void>;
+    sendNow(notifiables: Notifiable | Notifiable[], notification: Notification, channels?: string[]): Promise<void>;
+    /** On-demand: Notification.route('mail', 'a@b.c').notify(n). */
+    route(channel: string, route: unknown): Notifiable & {
+        notify(notification: Notification): Promise<void>;
+    };
+    extend(channel: string, factory: () => NotificationChannel): void;
+}
+declare const NotificationDispatcher: Token<NotificationDispatcher>;
+
+interface Lock {
+    /** Tries once. Returns whether it was acquired. */
+    get(): Promise<boolean>;
+    /** Tries once. Runs the callback and releases if acquired, else returns false. */
+    get<T>(callback: () => T | Promise<T>): Promise<T | false>;
+    /** Waits up to `seconds` to acquire. Throws LockTimeout (an OrielError, kind 'Http', status 423) on timeout. */
+    block<T>(seconds: number, callback?: () => T | Promise<T>): Promise<T | true>;
+    release(): Promise<boolean>;
+    forceRelease(): Promise<void>;
+    owner(): string;
+}
+interface CacheRepository {
+    get<T = unknown>(key: string): Promise<T | undefined>;
+    get<T>(key: string, defaultValue: T | (() => T)): Promise<T>;
+    many<T = unknown>(keys: string[]): Promise<Record<string, T | undefined>>;
+    has(key: string): Promise<boolean>;
+    missing(key: string): Promise<boolean>;
+    /** ttl in seconds; undefined = forever. */
+    put(key: string, value: unknown, ttlSeconds?: number): Promise<boolean>;
+    /** Only stores if the key is missing. Atomic in every driver. */
+    add(key: string, value: unknown, ttlSeconds?: number): Promise<boolean>;
+    increment(key: string, by?: number): Promise<number>;
+    decrement(key: string, by?: number): Promise<number>;
+    forever(key: string, value: unknown): Promise<boolean>;
+    pull<T = unknown>(key: string, defaultValue?: T): Promise<T | undefined>;
+    forget(key: string): Promise<boolean>;
+    flush(): Promise<boolean>;
+    remember<T>(key: string, ttlSeconds: number, callback: () => T | Promise<T>): Promise<T>;
+    rememberForever<T>(key: string, callback: () => T | Promise<T>): Promise<T>;
+    lock(name: string, seconds?: number, owner?: string): Lock;
+    /** Only supported by the redis store. Others throw. */
+    tags(names: string | string[]): CacheRepository;
+}
+interface CacheManager extends CacheRepository {
+    store(name?: string): CacheRepository;
+    extend(driver: string, factory: (config: Record<string, unknown>) => CacheRepository): void;
+}
+declare const CacheManager: Token<CacheManager>;
+
+type ListenerClass<E> = Class<{
+    handle(event: E): unknown;
+}>;
+type Listener<E> = ((event: E) => unknown) | ListenerClass<E>;
+interface EventDispatcher {
+    /** Class events (recommended) or string events like 'eloquent.created: Post'. */
+    listen<E>(events: Class<E> | string | Array<Class<E> | string>, listener: Listener<E>): void;
+    hasListeners(event: Class<unknown> | string): boolean;
+    /** Runs listeners in registration order. Listener classes that are queueable are queued. Returns results. */
+    dispatch(event: object | string, payload?: unknown[]): Promise<unknown[]>;
+    /** Stops at the first listener that returns something other than undefined. Returns that value. */
+    until(event: object | string, payload?: unknown[]): Promise<unknown>;
+    subscribe(subscriber: Class<{
+        subscribe(events: EventDispatcher): void;
+    }>): void;
+    forget(event: Class<unknown> | string): void;
+}
+declare const EventDispatcher: Token<EventDispatcher>;
+
+interface PutOptions {
+    visibility?: 'public' | 'private';
+    mimeType?: string;
+}
+/** Paths are relative to the disk root. Throws on paths that escape it ('../'). */
+interface Filesystem {
+    exists(path: string): Promise<boolean>;
+    missing(path: string): Promise<boolean>;
+    get(path: string): Promise<string>;
+    getBytes(path: string): Promise<Uint8Array>;
+    readStream(path: string): Promise<ReadableStream<Uint8Array>>;
+    put(path: string, contents: string | Uint8Array | ReadableStream<Uint8Array>, options?: PutOptions): Promise<boolean>;
+    /** Stores under a generated unique name. Returns the stored path. */
+    putFile(directory: string, file: UploadedFile, 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>;
+    /** Absolute local path (local disks only). */
+    path(path: string): string;
+}
+interface FilesystemManager extends Filesystem {
+    disk(name?: string): Filesystem;
+    extend(driver: string, factory: (config: Record<string, unknown>) => Filesystem): void;
+}
+declare const FilesystemManager: Token<FilesystemManager>;
+
+/** The Inertia page object (protocol v2). */
+interface InertiaPage {
+    component: string;
+    props: Record<string, unknown>;
+    url: string;
+    version: string | null;
+    encryptHistory?: boolean;
+    clearHistory?: boolean;
+    mergeProps?: string[];
+    deferredProps?: Record<string, string[]>;
+}
+interface InertiaResponse extends Responsable {
+    with(key: string | Record<string, unknown>, value?: unknown): this;
+    withViewData(key: string | Record<string, unknown>, value?: unknown): this;
+}
+type PropCallback<T = unknown> = () => T | Promise<T>;
+interface InertiaFactory {
+    render(component: string, props?: Record<string, unknown>): InertiaResponse;
+    share(key: string | Record<string, unknown>, value?: unknown): void;
+    getShared(key?: string): unknown;
+    version(version: string | (() => string | Promise<string>)): void;
+    /** Only evaluated on partial reloads that ask for it. */
+    optional<T>(callback: PropCallback<T>): unknown;
+    /** Loaded in a follow-up request after the first render. */
+    defer<T>(callback: PropCallback<T>, group?: string): unknown;
+    /** Always included, even in partial reloads. */
+    always<T>(value: T | PropCallback<T>): unknown;
+    /** Merged with the existing client-side value instead of replacing it. */
+    merge<T>(value: T | PropCallback<T>): unknown;
+    /** 409 + X-Inertia-Location for external redirects. */
+    location(url: string): Response;
+    setRootView(view: string): void;
+}
+declare const InertiaFactory: Token<InertiaFactory>;
+
+interface LiveSnapshot {
+    data: Record<string, unknown>;
+    memo: {
+        id: string;
+        /** ClassRegistry name of the component. */
+        name: string;
+        path: string;
+        method: string;
+        children: Record<string, [tag: string, id: string]>;
+        errors: Record<string, string[]>;
+    };
+    /** HMAC-SHA256 of JSON(data + memo), keyed by APP_KEY. */
+    checksum: string;
+}
+interface LiveEffects {
+    html?: string;
+    dispatches?: Array<{
+        name: string;
+        params: unknown[];
+    }>;
+    redirect?: string;
+    returns?: unknown[];
+}
+interface LiveUpdateRequest {
+    components: Array<{
+        /** JSON-encoded LiveSnapshot. */
+        snapshot: string;
+        updates: Record<string, unknown>;
+        calls: Array<{
+            method: string;
+            params: unknown[];
+        }>;
+    }>;
+}
+interface LiveUpdateResponse {
+    components: Array<{
+        snapshot: string;
+        effects: LiveEffects;
+    }>;
+}
+interface LiveManager {
+    register(component: Class<unknown>, name?: string): void;
+    /** Server-renders the first HTML (snapshot embedded). */
+    mount(component: string | Class<unknown>, params?: Record<string, unknown>): Promise<string>;
+    /** Checks checksums and CSRF, then applies updates and calls, re-renders and returns new snapshots. */
+    update(request: LiveUpdateRequest): Promise<LiveUpdateResponse>;
+    isLiveRequest(request: HttpRequest): boolean;
+}
+declare const LiveManager: Token<LiveManager>;
+
+export { type AbilityCallback, type Abstract, type ActionMethods, type Address, Application, type Arrayable, type Attachment, AuthFactory, type Authenticatable, type AuthenticationError, type Batch, type BodyInit, BusDispatcher, CacheManager, type CacheRepository, type Class, ClassRegistry, type Command, type Concrete, type ConfigCallbacks, ConfigRepository, ConsoleKernel, Container, type Content, type ControllerAction, type Cookie, CookieJar, type Credentials, type DatabaseConnection, DatabaseManager, type DriverName, Encrypter, type Enumerable, type Envelope, type ErrorKind, EventDispatcher, ExceptionCallbacks, ExceptionHandler, type ExceptionsConfigurator, type Factory, type FailedJob, FailedJobProvider, type Filesystem, FilesystemManager, Gate, type Guard, Hasher, type HeadersInit, type Htmlable, HttpKernel, HttpRequest, InertiaFactory, type InertiaPage, type InertiaResponse, type Job, type Jsonable, type Listener, type ListenerClass, type LiveEffects, LiveManager, type LiveSnapshot, type LiveUpdateRequest, type LiveUpdateResponse, type Lock, type LogLevel, LogManager, type Logger, MailManager, type MailRecipient, type MailTransport, type Mailable, type Mailer, type MessageBag, type Middleware, MiddlewareCallbacks, type MiddlewareClass, type MiddlewareConfigurator, type MiddlewareReference, type ModelInstance, type ModelNotFoundError, type ModelStatic, type MustVerifyEmail, type Next, type Notifiable, type Notification, type NotificationChannel, NotificationDispatcher, type Operator, type OrielError, type OutgoingMessage, PasswordBroker, type PasswordStatus, type PendingBatch, type PendingChain, type PendingMail, type Pipe, type PipeClosure, type PipeNext, type Pipeline, PipelineFactory, type PropCallback, type PutOptions, type QueryBuilder, type Queue, type QueueJob, QueueManager, type QueuePayload, type RedirectResponse, Redirector, type ResourceOptions, type Responsable, ResponseFactory, type Route, type RouteAction, type RouteClosure, RouteModelResolver, type RouteRegistrar, Router, RoutingPaths, type Row, type RuleCallback, type Rules, Schedule, type ScheduledEvent, type SentMessage, type ServiceProvider, type ServiceProviderClass, Session, type SessionHandler, type ShouldQueue, type StatefulGuard, type Token, type UploadedFile, UrlGenerator, type UserProvider, type ValidationError, ValidationFactory, type ValidationRule, type Validator, type View, ViewFactory, token };