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

package/dist/contracts.d.ts

@@ -198,6 +198,38 @@ interface SessionHandler {
     gc(maxLifetimeSeconds: number): Promise<void>;
 }
 
+/** 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>;
+
 /** 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];
@@ -243,12 +275,16 @@ interface HttpRequest {
     merge(values: Record<string, unknown>): this;
     file(key: string): UploadedFile | undefined;
     cookie(name: string): string | undefined;
+    /** Replace the parsed request cookies (EncryptCookies calls this after decrypting). */
+    setCookies(cookies: Record<string, string>): void;
     /** Route parameter (after model binding), or every parameter when called with no key. */
     route<T = unknown>(key?: string): T;
     session(): Session;
     /** The user resolved earlier by auth middleware. Undefined for guests. Use `await Auth.user()` to resolve lazily. */
     user<T = unknown>(guard?: string): T | undefined;
     setUserResolver(resolver: (guard?: string) => unknown): void;
+    /** Validates this request's input via the ValidationFactory; throws a Validation OrielError (422) on failure. */
+    validate<T = Record<string, unknown>>(rules: Rules, messages?: Record<string, string>, attributes?: Record<string, string>): Promise<T>;
 }
 declare const HttpRequest: Token<HttpRequest>;
 type Next = (request: HttpRequest) => Promise<Response>;
@@ -323,17 +359,28 @@ interface ResourceOptions {
     parameters?: Record<string, string>;
     names?: Record<string, string>;
 }
+/** The route matched for the current request (scope-local; set by the router before route middleware runs). */
+interface CurrentRoute {
+    readonly route: Route;
+    /** Route parameters after model binding, in URI order. */
+    readonly parameters: Record<string, unknown>;
+    /** Resolved route middleware instances, for HttpKernel.terminate(). */
+    readonly middleware: Middleware[];
+}
+declare const CurrentRoute: Token<CurrentRoute>;
 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;
+    get<C>(uri: string, action: ControllerAction<C> | RouteClosure | string): Route;
+    post<C>(uri: string, action: ControllerAction<C> | RouteClosure | string): Route;
+    put<C>(uri: string, action: ControllerAction<C> | RouteClosure | string): Route;
+    patch<C>(uri: string, action: ControllerAction<C> | RouteClosure | string): Route;
+    delete<C>(uri: string, action: ControllerAction<C> | RouteClosure | string): Route;
+    options<C>(uri: string, action: ControllerAction<C> | RouteClosure | string): Route;
+    any<C>(uri: string, action: ControllerAction<C> | RouteClosure | string): Route;
+    match<C>(methods: string[], uri: string, action: ControllerAction<C> | RouteClosure | string): Route;
     redirect(from: string, to: string, status?: number): Route;
     view(uri: string, view: string, data?: Record<string, unknown>): Route;
+    /** Route.inertia('/about', 'About', props): a GET route that renders an Inertia page (Laravel's Route::inertia). */
+    inertia(uri: string, component: string, props?: 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;
@@ -346,8 +393,17 @@ interface Router {
     /** Custom binding resolver. */
     bind(parameter: string, resolver: (value: string) => unknown | Promise<unknown>): void;
     pattern(parameter: string, pattern: string): void;
+    /** Name a middleware class, e.g. aliasMiddleware('auth', Authenticate). */
+    aliasMiddleware(name: string, middleware: MiddlewareClass): this;
+    /** Define (or replace) a middleware group such as 'web' or 'api'. */
+    middlewareGroup(name: string, middleware: MiddlewareReference[]): this;
+    /** Append to a group unless it is already present. */
+    pushMiddlewareToGroup(group: string, middleware: MiddlewareReference): this;
+    getMiddlewareGroups(): Record<string, MiddlewareReference[]>;
     getRoutes(): readonly Route[];
     current(): Route | undefined;
+    /** Match the request, bind parameters, run the route middleware and the action. Called by the Http kernel. */
+    dispatch(request: HttpRequest): Promise<Response>;
 }
 declare const Router: Token<Router>;
 /**
@@ -360,6 +416,15 @@ interface RouteModelResolver {
     resolveExplicit(model: Class<unknown>, value: string, field?: string): Promise<unknown>;
 }
 declare const RouteModelResolver: Token<RouteModelResolver>;
+/**
+ * Route name → parameters, for the typed route() and redirect().route() helpers. Empty until `oriel route:types`
+ * augments it (types/routes.d.ts); while it is empty any string is accepted. The contracts themselves keep taking
+ * strings: the framework builds route names at run time.
+ */
+interface RouteList {
+}
+/** A route name: the generated ones, or any string before `oriel route:types` has run. */
+type RouteName = [keyof RouteList] extends [never] ? string : Extract<keyof RouteList, string>;
 interface UrlGenerator {
     to(path: string, query?: Record<string, unknown>, absolute?: boolean): string;
     route(name: string, parameters?: unknown, absolute?: boolean): string;
@@ -461,7 +526,7 @@ interface LogManager extends Logger {
 }
 declare const LogManager: Token<LogManager>;
 
-type ErrorKind = 'Http' | 'ModelNotFound' | 'Validation' | 'Authentication' | 'Authorization' | 'TokenMismatch' | 'BindingResolution' | 'CircularDependency' | 'ContainerNotAvailable';
+type ErrorKind = 'Http' | 'Server' | 'ModelNotFound' | 'Validation' | 'Authentication' | 'Authorization' | 'TokenMismatch' | 'BindingResolution' | 'CircularDependency' | 'ContainerNotAvailable';
 /** Every error thrown by the framework implements this. The exception handler switches on `kind`. */
 interface OrielError extends Error {
     readonly kind: ErrorKind;
@@ -513,6 +578,11 @@ interface QueryBuilder<T = Row> {
     count(): Promise<number>;
     exists(): Promise<boolean>;
     insert(values: Row | Row[]): Promise<void>;
+    /**
+     * Inserts rows, skipping any that violate a unique key instead of failing (Laravel's insertOrIgnore). Returns the
+     * number of rows inserted. Nothing is thrown for a duplicate, so a caller's transaction stays usable on Postgres.
+     */
+    insertOrIgnore(values: Row | Row[]): Promise<number>;
     insertGetId(values: Row, keyName?: string): Promise<number | string>;
     update(values: Row): Promise<number>;
     upsert(values: Row | Row[], uniqueBy: string[], update?: string[]): Promise<number>;
@@ -529,6 +599,16 @@ interface DatabaseConnection {
     statement(sql: string, bindings?: readonly unknown[]): Promise<void>;
     /** Nested calls use savepoints. Rolls back if fn throws. */
     transaction<R>(fn: (connection: DatabaseConnection) => Promise<R>): Promise<R>;
+    /**
+     * Start a transaction that stays open, for every caller of this connection, until commit()/rollBack().
+     * Nested calls use savepoints. Meant for test isolation (RefreshDatabase); app code uses transaction(fn).
+     */
+    beginTransaction(): Promise<void>;
+    commit(): Promise<void>;
+    /** Rolls back the innermost level opened by beginTransaction(). Does nothing when none is open. */
+    rollBack(): Promise<void>;
+    /** 0 outside a transaction. */
+    transactionLevel(): number;
 }
 interface DatabaseManager extends DatabaseConnection {
     connection(name?: string): DatabaseConnection;
@@ -559,38 +639,6 @@ interface ModelStatic<M extends ModelInstance = ModelInstance> {
     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;
@@ -688,6 +736,10 @@ interface QueuePayload {
     pushedAt: number;
     batchId?: string;
     chain?: QueuePayload[];
+    /** Unix ms after which the job fails instead of retrying. */
+    retryUntil?: number;
+    /** Mark the job failed (instead of releasing it) when it times out. */
+    failOnTimeout?: boolean;
 }
 interface QueueJob {
     getJobId(): string;
@@ -770,6 +822,31 @@ interface BusDispatcher {
     findBatch(id: string): Promise<Batch | undefined>;
 }
 declare const BusDispatcher: Token<BusDispatcher>;
+/** What PendingBatch hands to the repository. Callbacks are jobs, because closures can't be serialized. */
+interface PendingBatchOptions {
+    name: string;
+    then: Job[];
+    catch: Job[];
+    finally: Job[];
+    allowFailures: boolean;
+    connection?: string;
+    queue?: string;
+}
+/** Stores batches and runs their bookkeeping (Laravel's BatchRepository). Bound by the Queue component. */
+interface BatchRepository {
+    store(options: PendingBatchOptions): Promise<Batch>;
+    find(id: string): Promise<Batch | undefined>;
+    /** Adds `amount` to both total and pending jobs, before the jobs are pushed. */
+    incrementTotalJobs(id: string, amount: number): Promise<void>;
+    /** A batched job succeeded: decrement pending, then run then/finally callbacks when due. */
+    recordSuccessfulJob(id: string, jobUuid: string): Promise<void>;
+    /** A batched job failed for good: count it, cancel unless failures are allowed, run catch/finally when due. */
+    recordFailedJob(id: string, jobUuid: string, error: unknown): Promise<void>;
+    markAsFinished(id: string): Promise<void>;
+    cancel(id: string): Promise<void>;
+    delete(id: string): Promise<void>;
+}
+declare const BatchRepository: Token<BatchRepository>;
 
 /** A CLI command. Signature uses Laravel syntax: 'mail:send {user} {--queue=default}'. */
 interface Command {
@@ -777,6 +854,29 @@ interface Command {
     readonly description: string;
     handle(): number | void | Promise<number | void>;
 }
+type OptionValue = string | boolean | string[] | undefined;
+/** `this` inside a closure command (Laravel's Command API). */
+interface CommandContext extends Command {
+    argument(name: string): string | string[] | undefined;
+    arguments(): Record<string, string | string[]>;
+    option(name: string): OptionValue;
+    options(): Record<string, OptionValue>;
+    info(message: string): void;
+    line(message?: string): void;
+    comment(message: string): void;
+    warn(message: string): void;
+    error(message: string): void;
+    newLine(count?: number): void;
+    table(headers: string[], rows: string[][]): void;
+    ask(question: string, defaultValue?: string): Promise<string>;
+    secret(question: string): Promise<string>;
+    confirm(question: string, defaultValue?: boolean): Promise<boolean>;
+    choice(question: string, choices: string[], defaultIndex?: number): Promise<string>;
+}
+/** What ConsoleKernel.command() returns. */
+interface ClosureCommand extends CommandContext {
+    purpose(description: string): this;
+}
 interface ConsoleKernel {
     /** Returns the exit code. */
     handle(argv: string[]): Promise<number>;
@@ -784,6 +884,10 @@ interface ConsoleKernel {
     /** Output buffered from the last call(). */
     output(): string;
     all(): Record<string, Command>;
+    /** Register command classes or instances (components call this from their provider's boot()). */
+    register(...commands: Array<Command | (new () => Command)>): void;
+    /** Closure command, like Artisan::command() in routes/console.ts. `this` is the command (argument(), info(), …). */
+    command(signature: string, handler: (this: CommandContext, ...args: unknown[]) => number | void | Promise<number | void>): ClosureCommand;
 }
 declare const ConsoleKernel: Token<ConsoleKernel>;
 interface ScheduledEvent {
@@ -854,6 +958,8 @@ interface Content {
     text?: string;
     /** Raw HTML (used when no view is given). */
     htmlString?: string;
+    /** Raw plain-text body (used when no text view is given). */
+    textString?: string;
     with?: Record<string, unknown>;
 }
 interface Attachment {
@@ -940,7 +1046,7 @@ interface Lock {
     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. */
+    /** Waits up to `seconds` to acquire. Throws LockTimeoutError (an OrielError, kind 'Server', status 500) on timeout. */
     block<T>(seconds: number, callback?: () => T | Promise<T>): Promise<T | true>;
     release(): Promise<boolean>;
     forceRelease(): Promise<void>;
@@ -1029,38 +1135,99 @@ interface FilesystemManager extends Filesystem {
 }
 declare const FilesystemManager: Token<FilesystemManager>;
 
-/** The Inertia page object (protocol v2). */
+/** Infinite-scroll metadata for one prop (page.scrollProps[path]). */
+interface InertiaScrollProp {
+    pageName: string;
+    previousPage: string | number | null;
+    nextPage: string | number | null;
+    currentPage: string | number | null;
+    reset: boolean;
+}
+/** A once prop the client keeps between visits (page.onceProps[key]). `expiresAt` is epoch milliseconds. */
+interface InertiaOnceProp {
+    prop: string;
+    expiresAt: number | null;
+}
+/**
+ * The Inertia page object (protocol v3, @inertiajs/core 3.x). Only component, props, url and version are always
+ * present; the other fields are left out when empty or false.
+ */
 interface InertiaPage {
     component: string;
     props: Record<string, unknown>;
+    /** Path and query, never absolute: '/posts?page=2'. */
     url: string;
-    version: string | null;
-    encryptHistory?: boolean;
-    clearHistory?: boolean;
+    /** '' when the app has no asset version. */
+    version: string;
+    sharedProps?: string[];
     mergeProps?: string[];
+    prependProps?: string[];
+    deepMergeProps?: string[];
+    /** '<prop path>.<key field>', e.g. 'posts.data.id'. */
+    matchPropsOn?: string[];
+    /** Group name → prop paths loaded after the first render. */
     deferredProps?: Record<string, string[]>;
+    rescuedProps?: string[];
+    scrollProps?: Record<string, InertiaScrollProp>;
+    onceProps?: Record<string, InertiaOnceProp>;
+    clearHistory?: true;
+    encryptHistory?: true;
+    flash?: Record<string, unknown>;
+    preserveFragment?: true;
 }
 interface InertiaResponse extends Responsable {
     with(key: string | Record<string, unknown>, value?: unknown): this;
     withViewData(key: string | Record<string, unknown>, value?: unknown): this;
+    rootView(view: string): this;
+    /** Flash data for the next page (page.flash), stored in the session. */
+    flash(key: string | Record<string, unknown>, value?: unknown): this;
 }
 type PropCallback<T = unknown> = () => T | Promise<T>;
+/** The SSR result spliced into the root view: the `head` tags and the rendered `body`. */
+interface InertiaSsrResponse {
+    head: string;
+    body: string;
+}
+/** Sends a page to the SSR server. Resolves to undefined when SSR is off, unreachable or failing. */
+interface InertiaSsrGateway {
+    dispatch(page: InertiaPage): Promise<InertiaSsrResponse | undefined>;
+}
+declare const InertiaSsrGateway: Token<InertiaSsrGateway>;
 interface InertiaFactory {
     render(component: string, props?: Record<string, unknown>): InertiaResponse;
     share(key: string | Record<string, unknown>, value?: unknown): void;
+    /** A shared once prop: sent on the first visit, then kept by the client. */
+    shareOnce(key: string, callback: PropCallback): void;
     getShared(key?: string): unknown;
-    version(version: string | (() => string | Promise<string>)): void;
+    flushShared(): void;
+    version(version: string | null | (() => string | null | Promise<string | null>)): void;
+    getVersion(): Promise<string>;
+    setRootView(view: 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. */
+    /** Appended to the existing client-side value instead of replacing it. */
     merge<T>(value: T | PropCallback<T>): unknown;
-    /** 409 + X-Inertia-Location for external redirects. */
+    /** Deep-merged with the existing client-side value. */
+    deepMerge<T>(value: T | PropCallback<T>): unknown;
+    /** Resolved once, then remembered by the client. */
+    once<T>(callback: PropCallback<T>): unknown;
+    /** Infinite scroll over a paginator: merged page by page, with scroll metadata. */
+    scroll<T>(value: T | PropCallback<T>, wrapper?: string): unknown;
+    /** Flash data for the next page (page.flash), stored in the session. */
+    flash(key: string | Record<string, unknown>, value?: unknown): this;
+    encryptHistory(encrypt?: boolean): void;
+    /** The next page tells the client to clear its encrypted history. */
+    clearHistory(): void;
+    /** The next page keeps the URL fragment of the request that redirected to it. */
+    preserveFragment(): void;
+    /** 409 + X-Inertia-Location for Inertia requests, a plain 302 otherwise. */
     location(url: string): Response;
-    setRootView(view: string): void;
+    /** Redirect back (Inertia.flash('saved', true).back()). */
+    back(fallback?: string, status?: number): RedirectResponse;
 }
 declare const InertiaFactory: Token<InertiaFactory>;
 
@@ -1114,4 +1281,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, 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 };
+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 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, 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

@@ -1,6 +1,7 @@
 import {
   Application,
   AuthFactory,
+  BatchRepository,
   BusDispatcher,
   CacheManager,
   ClassRegistry,
@@ -8,6 +9,7 @@ import {
   ConsoleKernel,
   Container,
   CookieJar,
+  CurrentRoute,
   DatabaseManager,
   Encrypter,
   EventDispatcher,
@@ -20,6 +22,7 @@ import {
   HttpKernel,
   HttpRequest,
   InertiaFactory,
+  InertiaSsrGateway,
   LiveManager,
   LogManager,
   MailManager,
@@ -39,10 +42,11 @@ import {
   ValidationFactory,
   ViewFactory,
   token
-} from "./chunk-P64C7IEP.js";
+} from "./chunk-3ZRPBRAE.js";
 export {
   Application,
   AuthFactory,
+  BatchRepository,
   BusDispatcher,
   CacheManager,
   ClassRegistry,
@@ -50,6 +54,7 @@ export {
   ConsoleKernel,
   Container,
   CookieJar,
+  CurrentRoute,
   DatabaseManager,
   Encrypter,
   EventDispatcher,
@@ -62,6 +67,7 @@ export {
   HttpKernel,
   HttpRequest,
   InertiaFactory,
+  InertiaSsrGateway,
   LiveManager,
   LogManager,
   MailManager,