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

package/dist/contracts.d.ts

@@ -640,6 +640,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;
@@ -655,6 +657,19 @@ interface ModelStatic<M extends ModelInstance = ModelInstance> {
     find(id: unknown): Promise<M | undefined>;
     findOrFail(id: unknown): Promise<M>;
 }
+/**
+ * What decides a paginator's page and the path of its links when the request doesn't (Laravel's
+ * Paginator::currentPageResolver and currentPathResolver, which Livewire's WithPagination replaces). Live binds one for
+ * the application, which answers while a WithPagination component mounts, runs an update's hooks and actions, or
+ * renders. Unbound, or `undefined` from a method, the paginators read the request (`?page=` and its URL).
+ */
+interface PaginationState {
+    /** The page to show for `pageName` ('page' by default). */
+    currentPage(pageName: string): number | undefined;
+    /** The base path of the page links. */
+    currentPath(): string | undefined;
+}
+declare const PaginationState: Token<PaginationState>;
 
 interface Authenticatable {
     getAuthIdentifierName(): string;
@@ -723,6 +738,11 @@ interface MustVerifyEmail {
 
 /** 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. */
@@ -909,6 +929,15 @@ interface ConsoleKernel {
 declare const ConsoleKernel: Token<ConsoleKernel>;
 interface ScheduledEvent {
     readonly expression: string;
+    /**
+     * What a Schedule.command() event runs: the command and its parameters ('posts:announce --force'), without the
+     * runtime and `oriel` in front. Undefined for call() and job() events. Laravel's `$event->command`.
+     */
+    readonly command: string | undefined;
+    /** Whether withoutOverlapping() was called. Laravel's `$event->withoutOverlapping`, a method's name here. */
+    readonly preventsOverlapping: boolean;
+    /** Minutes the withoutOverlapping() lock is kept at most (1440 unless withoutOverlapping() says). Laravel's `$event->expiresAt`. */
+    readonly expiresAt: number;
     cron(expression: string): this;
     everyMinute(): this;
     everyFiveMinutes(): this;
@@ -937,6 +966,13 @@ interface ScheduledEvent {
     runInBackground(): this;
     name(name: string): this;
     description(description: string): this;
+    /** The name, else the description: the command, the job's class, or 'Closure'. schedule:list shows it. */
+    getSummaryForDisplay(): string;
+    /**
+     * The cache lock withoutOverlapping() holds: `framework/schedule-` and the sha1 of the expression and the command,
+     * or of the name for call() and job() events (Laravel's mutexName()). schedule:clear-cache deletes it.
+     */
+    mutexName(): string;
     isDue(now: Date): boolean;
     run(): Promise<void>;
 }
@@ -1015,6 +1051,8 @@ interface PendingMail {
     cc(recipients: MailRecipient | MailRecipient[]): this;
     bcc(recipients: MailRecipient | MailRecipient[]): this;
     send(mailable: Mailable): Promise<SentMessage | undefined>;
+    /** Sends at once, even when the mailable is queueable (Laravel's sendNow()). A fake resolves undefined. */
+    sendNow(mailable: Mailable): Promise<SentMessage | undefined>;
     queue(mailable: Mailable): Promise<void>;
     later(delaySeconds: number, mailable: Mailable): Promise<void>;
 }
@@ -1022,6 +1060,8 @@ 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>;
+    /** Sends to the envelope's recipients at once, even when the mailable is queueable (Laravel's sendNow()). */
+    sendNow(mailable: Mailable): Promise<SentMessage | undefined>;
     queue(mailable: Mailable): Promise<void>;
 }
 interface MailManager extends Mailer {
@@ -1057,6 +1097,28 @@ interface NotificationDispatcher {
     extend(channel: string, factory: () => NotificationChannel): void;
 }
 declare const NotificationDispatcher: Token<NotificationDispatcher>;
+/**
+ * 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 extends ModelInstance {
+    /** 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;
+}
 
 interface Lock {
     /** Tries once. Returns whether it was acquired. */
@@ -1322,4 +1384,4 @@ interface LiveManager {
 }
 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, BatchRepository, type BodyInit, BusDispatcher, CacheManager, type CacheRepository, type Class, ClassRegistry, type ClosureCommand, type Command, type CommandContext, type Concrete, type ConfigCallbacks, ConfigRepository, ConsoleKernel, Container, type Content, type ControllerAction, type Cookie, CookieJar, type Credentials, CurrentRoute, 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 InertiaOnceProp, type InertiaPage, type InertiaResponse, type InertiaScrollProp, InertiaSsrGateway, type InertiaSsrResponse, type InvokableClass, 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 OptionValue, type OrielError, type OutgoingMessage, PasswordBroker, type PasswordStatus, type PendingBatch, type PendingBatchOptions, 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, RateLimiter, type RedirectResponse, Redirector, type ResourceOptions, type Responsable, ResponseFactory, type Route, type RouteAction, type RouteClosure, type RouteList, RouteModelResolver, type RouteName, 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 };
+export { type AbilityCallback, type Abstract, type ActionMethods, type Address, Application, type Arrayable, type Attachment, AuthFactory, type Authenticatable, type AuthenticationError, type Batch, BatchRepository, type BodyInit, BusDispatcher, CacheManager, type CacheRepository, type Class, ClassRegistry, type ClosureCommand, type Command, type CommandContext, type Concrete, type ConfigCallbacks, ConfigRepository, ConsoleKernel, Container, type Content, type ControllerAction, type Cookie, CookieJar, type Credentials, CurrentRoute, type DatabaseConnection, DatabaseManager, type DatabaseNotification, 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 InertiaOnceProp, type InertiaPage, type InertiaResponse, type InertiaScrollProp, InertiaSsrGateway, type InertiaSsrResponse, type InvokableClass, 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 OptionValue, type OrielError, type OutgoingMessage, PaginationState, PasswordBroker, type PasswordStatus, type PendingBatch, type PendingBatchOptions, 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, RateLimiter, type RedirectResponse, Redirector, type ResourceOptions, type Responsable, ResponseFactory, type Route, type RouteAction, type RouteClosure, type RouteList, RouteModelResolver, type RouteName, 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 };

package/dist/contracts.js

@@ -28,6 +28,7 @@ import {
   MailManager,
   MiddlewareCallbacks,
   NotificationDispatcher,
+  PaginationState,
   PasswordBroker,
   PipelineFactory,
   QueueManager,
@@ -43,7 +44,7 @@ import {
   ValidationFactory,
   ViewFactory,
   token
-} from "./chunk-WSGWYXAO.js";
+} from "./chunk-I63ZFMX6.js";
 export {
   Application,
   AuthFactory,
@@ -74,6 +75,7 @@ export {
   MailManager,
   MiddlewareCallbacks,
   NotificationDispatcher,
+  PaginationState,
   PasswordBroker,
   PipelineFactory,
   QueueManager,

package/dist/index.d-BJyJx6U1.d.ts

@@ -0,0 +1,319 @@
+import { Enumerable, ServiceProvider as ServiceProvider$1, Application, ClassRegistry as ClassRegistry$1, Class, Abstract, ConfigRepository } from './contracts.js';
+
+type Operator = '=' | '==' | '===' | '!=' | '!==' | '<>' | '<' | '<=' | '>' | '>=';
+
+type Getter<T, V = unknown> = (keyof T & string) | ((item: T) => V);
+declare class Collection<T> implements Enumerable<T> {
+    protected readonly items: T[];
+    constructor(items?: Iterable<T>);
+    static make<T>(items?: Iterable<T>): Collection<T>;
+    /** Laravel semantics: callback receives 1..n. */
+    static times<T>(count: number, callback: (index: number) => T): Collection<T>;
+    [Symbol.iterator](): Iterator<T>;
+    all(): T[];
+    count(): number;
+    isEmpty(): boolean;
+    isNotEmpty(): boolean;
+    toArray(): unknown[];
+    toJSON(): T[];
+    toJson(): string;
+    map<U>(callback: (item: T, index: number) => U): Collection<U>;
+    flatMap<U>(callback: (item: T, index: number) => U | U[] | Collection<U>): Collection<U>;
+    filter(callback?: (item: T, index: number) => unknown): Collection<T>;
+    reject(callback: (item: T, index: number) => unknown): Collection<T>;
+    /** Return false from the callback to stop. */
+    each(callback: (item: T, index: number) => unknown): this;
+    reduce<U>(callback: (carry: U, item: T, index: number) => U, initial: U): U;
+    first(): T | undefined;
+    first<D = undefined>(callback: (item: T, index: number) => unknown, defaultValue?: D): T | D;
+    last(): T | undefined;
+    last<D = undefined>(callback: (item: T, index: number) => unknown, defaultValue?: D): T | D;
+    where(key: Getter<T>, value: unknown): Collection<T>;
+    where(key: Getter<T>, operator: Operator, value: unknown): Collection<T>;
+    firstWhere(key: Getter<T>, value: unknown): T | undefined;
+    firstWhere(key: Getter<T>, operator: Operator, value: unknown): T | undefined;
+    whereIn(key: Getter<T>, values: readonly unknown[]): Collection<T>;
+    whereNotIn(key: Getter<T>, values: readonly unknown[]): Collection<T>;
+    pluck<K extends keyof T & string>(key: K): Collection<T[K]>;
+    keyBy(key: Getter<T>): Record<string, T>;
+    groupBy(key: Getter<T>): Record<string, Collection<T>>;
+    mapWithKeys<V>(callback: (item: T, index: number) => readonly [string, V]): Record<string, V>;
+    sortBy(key: Getter<T>, direction?: 'asc' | 'desc'): Collection<T>;
+    sortByDesc(key: Getter<T>): Collection<T>;
+    sum(key?: Getter<T>): number;
+    avg(key?: Getter<T>): number | undefined;
+    min(key?: Getter<T>): number | undefined;
+    max(key?: Getter<T>): number | undefined;
+    unique(key?: Getter<T>): Collection<T>;
+    chunk(size: number): Collection<Collection<T>>;
+    /** Negative count takes from the end. */
+    take(count: number): Collection<T>;
+    skip(count: number): Collection<T>;
+    slice(offset: number, length?: number): Collection<T>;
+    values(): Collection<T>;
+    contains(key: keyof T & string, value: unknown): boolean;
+    contains(callback: (item: T) => boolean): boolean;
+    contains(value: unknown): boolean;
+    /** Mutates, like Laravel. */
+    push(...values: T[]): this;
+    concat(values: Iterable<T>): Collection<T>;
+    partition(callback: (item: T, index: number) => unknown): [Collection<T>, Collection<T>];
+    implode(glue: string): string;
+    implode(key: keyof T & string, glue: string): string;
+    when<U = this>(condition: unknown, callback: (collection: this) => U): U | this;
+    pipe<U>(callback: (collection: this) => U): U;
+    tap(callback: (collection: this) => void): this;
+}
+declare function collect<T>(items?: Iterable<T>): Collection<T>;
+
+type Source<T> = () => AsyncIterable<T> | Iterable<T>;
+/** Pull-based and async: for DB cursors (Model.lazy()) and large files. */
+declare class LazyCollection<T> implements AsyncIterable<T> {
+    private readonly source;
+    constructor(source: Source<T>);
+    static make<T>(source: Source<T>): LazyCollection<T>;
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+    map<U>(callback: (item: T, index: number) => U | Promise<U>): LazyCollection<U>;
+    filter(callback: (item: T, index: number) => unknown): LazyCollection<T>;
+    take(count: number): LazyCollection<T>;
+    chunk(size: number): LazyCollection<Collection<T>>;
+    /** Return false from the callback to stop. */
+    each(callback: (item: T, index: number) => unknown): Promise<void>;
+    first(callback?: (item: T) => unknown): Promise<T | undefined>;
+    count(): Promise<number>;
+    collect(): Promise<Collection<T>>;
+}
+
+/**
+ * Laravel's Stringable: a string with Str's helpers as chainable methods, each returning a new Stringable.
+ * `Str.of(' Café ').trim().slug().toString()` is 'cafe'; `request().string('q')` returns one. It prints as its string.
+ */
+declare class Stringable {
+    #private;
+    constructor(value?: string);
+    after(search: string): Stringable;
+    afterLast(search: string): Stringable;
+    append(...values: string[]): Stringable;
+    ascii(): Stringable;
+    before(search: string): Stringable;
+    beforeLast(search: string): Stringable;
+    between(from: string, to: string): Stringable;
+    camel(): Stringable;
+    contains(needles: string | string[]): boolean;
+    endsWith(needles: string | string[]): boolean;
+    /** The same string as `value` (a string or another Stringable). */
+    exactly(value: string | Stringable): boolean;
+    /** The parts between the delimiters, as a Collection (PHP's explode()). */
+    explode(delimiter: string): Collection<string>;
+    finish(cap: string): Stringable;
+    /** Wildcard match, as Str.is(): `*` matches anything. */
+    is(pattern: string): boolean;
+    isEmpty(): boolean;
+    isNotEmpty(): boolean;
+    kebab(): Stringable;
+    lcfirst(): Stringable;
+    /** The number of characters (code points, as PHP's mb_strlen()). */
+    length(): number;
+    limit(limit?: number, end?: string): Stringable;
+    lower(): Stringable;
+    /** Strips whitespace and invisible characters from the start, or the characters given. */
+    ltrim(characters?: string): Stringable;
+    plural(count?: number): Stringable;
+    prepend(...values: string[]): Stringable;
+    /** Replaces every occurrence of the search string (or of each of several) with `replace`. */
+    replace(search: string | string[], replace: string): Stringable;
+    /** Strips whitespace and invisible characters from the end, or the characters given. */
+    rtrim(characters?: string): Stringable;
+    singular(): Stringable;
+    slug(separator?: string): Stringable;
+    snake(delimiter?: string): Stringable;
+    start(prefix: string): Stringable;
+    startsWith(needles: string | string[]): boolean;
+    studly(): Stringable;
+    title(): Stringable;
+    /** PHP's filter_var(FILTER_VALIDATE_BOOLEAN): '1', 'true', 'on' and 'yes' (any case, trimmed) are true. */
+    toBoolean(): boolean;
+    /** PHP's floatval(): the leading number, else 0. */
+    toFloat(): number;
+    /** PHP's intval(): the leading digits, else 0. */
+    toInteger(): number;
+    toJSON(): string;
+    toString(): string;
+    /** Strips whitespace and invisible characters from both ends (Laravel's Str::trim()), or the characters given. */
+    trim(characters?: string): Stringable;
+    ucfirst(): Stringable;
+    upper(): Stringable;
+    value(): string;
+}
+
+declare const Str: {
+    /** Laravel's Str::of(): the value as a Stringable, for chaining: Str.of(title).trim().slug(). */
+    of: (value?: unknown) => Stringable;
+    ucfirst: (v: string) => string;
+    lcfirst: (v: string) => string;
+    studly: (v: string) => string;
+    camel: (v: string) => string;
+    snake: (v: string, delimiter?: string) => string;
+    kebab: (v: string) => string;
+    title: (v: string) => string;
+    /** Laravel's Str::ascii(): the value in plain ASCII ('Café' → 'Cafe', 'Ελληνικά' → 'Ellinika'), as for English. */
+    ascii: (v: string) => string;
+    /**
+     * Laravel's Str::slug(): transliterated to ASCII first (unless `language` is null), '@' read as 'at', then lower-cased
+     * letters and digits joined by the separator: 'Café crème' → 'cafe-creme'. What has no ASCII form is dropped.
+     */
+    slug: (title: string, separator?: string, language?: "en" | null, dictionary?: Readonly<Record<string, string>>) => string;
+    plural: (v: string, count?: number) => string;
+    singular: (v: string) => string;
+    random: (length?: number) => string;
+    uuid: () => `${string}-${string}-${string}-${string}-${string}`;
+    /**
+     * A version 7 UUID (RFC 9562): the time in milliseconds first, so ids from later milliseconds sort after earlier ones
+     * (within one millisecond the order is random). Throws a TypeError for a time before 1970, after 10889 or invalid.
+     */
+    uuid7: (time?: Date) => string;
+    /**
+     * A ULID: 26 upper-case Crockford characters, ten for the time in milliseconds and sixteen random, so ids from later
+     * milliseconds sort after earlier ones. Throws a TypeError for a time before 1970, after 10889 or invalid.
+     */
+    ulid: (time?: Date) => string;
+    /** Laravel's Str::isUuid(): five groups of hex digits, any version. */
+    isUuid: (value: unknown) => value is string;
+    /** Laravel's Str::isUlid(): 26 Crockford characters in either case, the first at most 7. */
+    isUlid: (value: unknown) => value is string;
+    /** Wildcard match: `*` matches anything; everything else is literal. */
+    is: (pattern: string, value: string) => boolean;
+    startsWith: (v: string, needles: string | string[]) => boolean;
+    endsWith: (v: string, needles: string | string[]) => boolean;
+    contains: (v: string, needles: string | string[]) => boolean;
+    after: (v: string, search: string) => string;
+    afterLast: (v: string, search: string) => string;
+    before: (v: string, search: string) => string;
+    beforeLast: (v: string, search: string) => string;
+    between: (v: string, from: string, to: string) => string;
+    limit: (v: string, limit?: number, end?: string) => string;
+    start: (v: string, prefix: string) => string;
+    finish: (v: string, cap: string) => string;
+};
+
+type Obj = Record<string, unknown>;
+declare const Arr: {
+    get<T = unknown>(target: unknown, key: string | undefined, defaultValue?: T): T;
+    has(target: unknown, key: string): boolean;
+    set(target: Obj, key: string, value: unknown): Obj;
+    forget(target: Obj, key: string): void;
+    dot(target: Obj, prefix?: string): Obj;
+    undot(flat: Obj): Obj;
+    only<T extends Obj>(target: T, keys: string[]): Partial<T>;
+    except<T extends Obj>(target: T, keys: string[]): Partial<T>;
+    wrap<T>(value: T | T[] | null | undefined): T[];
+    first<T, D = undefined>(items: readonly T[], predicate?: (item: T, index: number) => boolean, defaultValue?: D): T | D;
+    last<T, D = undefined>(items: readonly T[], predicate?: (item: T, index: number) => boolean, defaultValue?: D): T | D;
+};
+
+declare abstract class ServiceProvider implements ServiceProvider$1 {
+    protected readonly app: Application;
+    constructor(app: Application);
+    register(): void;
+    boot(): void | Promise<void>;
+    /** Package defaults under `key`; values the app already set win (shallow merge, like Laravel). */
+    protected mergeConfigFrom(defaults: Record<string, unknown>, key: string): void;
+}
+
+interface FacadeStatics<T> {
+    getFacadeRoot(): T;
+    /** Replace the instance in the current container (used by X.fake()). */
+    swap(instance: T): void;
+}
+type Facade<T, X = object> = T & X & FacadeStatics<T>;
+declare function facade<T extends object, X extends object = object>(abstract: Abstract<T>, extras?: X): Facade<T, X>;
+
+declare class ClassRegistry implements ClassRegistry$1 {
+    private readonly byName;
+    private readonly byClass;
+    register(cls: Class<unknown>, name?: string): string;
+    nameOf(cls: Class<unknown>): string | undefined;
+    resolve<T = unknown>(name: string): Class<T>;
+    has(name: string): boolean;
+}
+
+/**
+ * The application, or an abstract resolved from the current container.
+ * Inside a request scope, app().make()/instance()/… act on that scope, so app().make(X) sees scoped services.
+ */
+declare function app(): Application;
+declare function app<T>(abstract: Abstract<T>): T;
+declare function config(): ConfigRepository;
+declare function config(values: Record<string, unknown>): void;
+declare function config<T = unknown>(key: string, defaultValue?: T): T;
+declare const now: () => Date;
+declare const value: <T>(v: T | (() => T)) => T;
+declare function tap<T>(target: T, callback: (target: T) => void): T;
+/** Calls fn up to `times` times (attempt numbers are 1-based). Rethrows the last error, or the first one `when` rejects. */
+declare function retry<T>(times: number, fn: (attempt: number) => T | Promise<T>, sleepMs?: number | ((attempt: number) => number), when?: (error: unknown) => boolean): Promise<T>;
+
+/**
+ * Laravel's __(): the line for `key` with `:placeholders` filled (`:name`, `:Name` capitalized, `:NAME` upper-cased),
+ * longest placeholder first. A key with no line comes back as is, so a sentence can be its own key:
+ * __('auth.failed'), __('auth.throttle', { seconds: 30 }), __('A reset link will be sent if the account exists.').
+ */
+declare function __(key: string, replace?: Record<string, string | number>): string;
+
+/**
+ * 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 };
+}
+
+export { Arr as A, Collection as C, type Facade as F, LazyCollection as L, ServiceProvider as S, __ as _, Stringable as a, ClassRegistry as b, type FacadeStatics as c, Str as d, app as e, fileType as f, collect as g, config as h, facade as i, now as n, retry as r, tap as t, value as v };