@orieljs/inertia 0.1.0-alpha.10

package/dist/index.d.ts

@@ -0,0 +1,633 @@
+import { PropCallback, InertiaScrollProp, InertiaOnceProp, HttpRequest, Session, Container, OrielError, InertiaResponse, InertiaPage, InertiaFactory, Application, RedirectResponse, Htmlable, Middleware, Next, InertiaSsrGateway, InertiaSsrResponse, Route, ConsoleKernel } from '@orieljs/contracts';
+import { ServiceProvider } from '@orieljs/support';
+import { spawn } from 'node:child_process';
+
+/** The Inertia protocol headers (inertia-laravel's Support\Header). */
+declare const Header: {
+    readonly INERTIA: "X-Inertia";
+    readonly ERROR_BAG: "X-Inertia-Error-Bag";
+    readonly LOCATION: "X-Inertia-Location";
+    readonly REDIRECT: "X-Inertia-Redirect";
+    readonly VERSION: "X-Inertia-Version";
+    readonly PARTIAL_COMPONENT: "X-Inertia-Partial-Component";
+    readonly PARTIAL_ONLY: "X-Inertia-Partial-Data";
+    readonly PARTIAL_EXCEPT: "X-Inertia-Partial-Except";
+    readonly RESET: "X-Inertia-Reset";
+    readonly INFINITE_SCROLL_MERGE_INTENT: "X-Inertia-Infinite-Scroll-Merge-Intent";
+    readonly EXCEPT_ONCE_PROPS: "X-Inertia-Except-Once-Props";
+};
+/** 'a,b,,c' → ['a', 'b', 'c']; empty or missing → undefined ("not given"), like PropsResolver::parseHeader. */
+declare function parseList(value: string | undefined): string[] | undefined;
+
+/** A value or a (possibly async) callback that produces it. */
+type PropValue<T> = T | PropCallback<T>;
+/** Where a mergeable prop is merged on the client (Laravel's MergesProps). */
+interface MergeState {
+    merge: boolean;
+    deep: boolean;
+    append: boolean;
+    appendPaths: string[];
+    prependPaths: string[];
+    matchOn: string[];
+}
+/** Once-prop settings (Laravel's ResolvesOnce). */
+interface OnceState {
+    once: boolean;
+    fresh: boolean;
+    key: string | undefined;
+    ttlSeconds: number | undefined;
+}
+/**
+ * The base of every Inertia prop type. `resolve()` produces the value; the flags say how the PropsResolver treats
+ * it. Subclasses switch the behaviours on, which is how Laravel's traits and marker interfaces work.
+ */
+declare abstract class Prop<T = unknown> {
+    protected readonly value: PropValue<T>;
+    /** A phantom field that carries the value type for the generated page props. Never set at runtime. */
+    readonly __value?: T;
+    /** Which prop type this is: the generated page props make deferred and optional props optional keys. */
+    abstract readonly kind: 'always' | 'optional' | 'defer' | 'merge' | 'once' | 'scroll';
+    protected readonly mergeState: MergeState;
+    protected readonly onceState: OnceState;
+    protected deferred: boolean;
+    protected deferGroup: string | undefined;
+    constructor(value: PropValue<T>);
+    /** Calls the callback, if the value is one. */
+    resolve(): Promise<unknown>;
+    /** Never sent on the first load (OptionalProp, DeferProp). */
+    ignoresFirstLoad(): boolean;
+    /** Sent even when a partial reload didn't ask for it (AlwaysProp). */
+    isAlways(): boolean;
+    /** Errors are reported and the prop is left out, instead of failing the page (defer(..., { rescue: true })). */
+    shouldRescue(): boolean;
+    /** once(), once(false), once(true, { as: 'key', until: 3600 }). */
+    once(value?: boolean, options?: {
+        as?: string;
+        until?: Date | number;
+    }): this;
+    /** A custom once key, so pages can share the prop under different names. */
+    as(key: string): this;
+    /** Send the prop again even though the client already has it. */
+    fresh(value?: boolean): this;
+    /** Expire after a number of seconds, or at a Date. */
+    until(delay: Date | number): this;
+    isMergeable(): boolean;
+    shouldMerge(): boolean;
+    shouldDeepMerge(): boolean;
+    matchesOn(): string[];
+    appendsAtRoot(): boolean;
+    prependsAtRoot(): boolean;
+    appendsAtPaths(): string[];
+    prependsAtPaths(): string[];
+    protected mergesAtRoot(): boolean;
+    isDeferrable(): boolean;
+    shouldDefer(): boolean;
+    group(): string;
+    isOnceable(): boolean;
+    shouldResolveOnce(): boolean;
+    shouldBeRefreshed(): boolean;
+    getKey(): string | undefined;
+    /** Epoch milliseconds, or null when the prop never expires. */
+    expiresAt(): number | null;
+}
+/** The fluent merge API shared by MergeProp, DeferProp and ScrollProp. */
+declare abstract class MergeableProp<T = unknown> extends Prop<T> {
+    #private;
+    isMergeable(): boolean;
+    merge(): this;
+    deepMerge(): this;
+    /** Match array items on these keys instead of appending duplicates: matchOn('id'). */
+    matchOn(keys: string | string[]): this;
+    /** append() at the root, append('data') at a path, append('data', 'id') with a match key, or a map of both. */
+    append(path?: boolean | string | string[] | Record<string, string>, matchOn?: string): this;
+    prepend(path?: boolean | string | string[] | Record<string, string>, matchOn?: string): this;
+}
+/** Seconds from now until `delay` (a Date, or a number of seconds). */
+declare function secondsUntil(delay: Date | number): number;
+
+/** Sent on every response, even partial reloads that didn't ask for it (Inertia::always). */
+declare class AlwaysProp<T = unknown> extends Prop<T> {
+    readonly kind: "always";
+    isAlways(): boolean;
+}
+/** Only evaluated on partial reloads that ask for it (Inertia::optional). */
+declare class OptionalProp<T = unknown> extends Prop<T> {
+    readonly kind: "optional";
+    constructor(callback: PropCallback<T>);
+    ignoresFirstLoad(): boolean;
+    isOnceable(): boolean;
+}
+/** Loaded by the client in a follow-up request, grouped (Inertia::defer). */
+declare class DeferProp<T = unknown> extends MergeableProp<T> {
+    #private;
+    readonly kind: "defer";
+    constructor(callback: PropCallback<T>, group?: string, options?: {
+        rescue?: boolean;
+    });
+    ignoresFirstLoad(): boolean;
+    isDeferrable(): boolean;
+    isOnceable(): boolean;
+    shouldRescue(): boolean;
+}
+/** Merged with the client's current value on partial reloads (Inertia::merge / Inertia::deepMerge). */
+declare class MergeProp<T = unknown> extends MergeableProp<T> {
+    readonly kind: "merge";
+    constructor(value: PropValue<T>);
+    isOnceable(): boolean;
+}
+/** Resolved once, then kept by the client until it expires (Inertia::once). */
+declare class OnceProp<T = unknown> extends Prop<T> {
+    readonly kind: "once";
+    constructor(callback: PropCallback<T>);
+    isOnceable(): boolean;
+}
+/** Page metadata for infinite scroll (Laravel's ProvidesScrollMetadata). */
+interface ScrollMetadata {
+    pageName: string;
+    previousPage: string | number | null;
+    nextPage: string | number | null;
+    currentPage: string | number | null;
+}
+type MetadataResolver = (value: unknown) => ScrollMetadata;
+/** Laravel's ScrollMetadata::fromPaginator for the Database paginators (matched by shape). */
+declare function scrollMetadataFrom(value: unknown): ScrollMetadata;
+/** A paginated prop the client merges page by page (Inertia::scroll). */
+declare class ScrollProp<T = unknown> extends MergeableProp<T> {
+    #private;
+    readonly wrapper: string;
+    private readonly metadataResolver?;
+    readonly kind: "scroll";
+    constructor(value: PropValue<T>, wrapper?: string, metadataResolver?: MetadataResolver | undefined);
+    isDeferrable(): boolean;
+    /** Load the prop after the first render, like a deferred prop. */
+    defer(group?: string): this;
+    /** 'prepend' from the X-Inertia-Infinite-Scroll-Merge-Intent header prepends the wrapper; anything else appends. */
+    configureMergeIntent(intent: string | undefined): this;
+    /** Resolves once and caches, because both the value and its metadata need it. */
+    resolve(): Promise<unknown>;
+    metadata(): Promise<ScrollMetadata>;
+}
+declare const isProp: (value: unknown) => value is Prop;
+
+type Obj$3 = Record<string, unknown>;
+/** The page fields the resolver produces next to the props. Empty fields are left out. */
+interface PropsMetadata {
+    sharedProps?: string[];
+    mergeProps?: string[];
+    prependProps?: string[];
+    deepMergeProps?: string[];
+    matchPropsOn?: string[];
+    deferredProps?: Record<string, string[]>;
+    rescuedProps?: string[];
+    scrollProps?: Record<string, InertiaScrollProp>;
+    onceProps?: Record<string, InertiaOnceProp>;
+}
+interface PropsResolverOptions {
+    /** config('inertia.expose_shared_prop_keys'), default true. */
+    exposeSharedPropKeys?: boolean;
+    /** Reports a rescued deferred prop's error (the exception handler). */
+    report?: (error: unknown) => void | Promise<void>;
+}
+/**
+ * inertia-laravel's PropsResolver: walks the shared and page props, filters them for partial reloads, skips what
+ * the first load must not send (optional, deferred, already-loaded once props), resolves callbacks and toJSON()
+ * values, and collects the page metadata (merge, deferred, once, scroll, rescued, shared keys).
+ */
+declare class PropsResolver {
+    #private;
+    private readonly options;
+    constructor(request: HttpRequest, component: string, options?: PropsResolverOptions);
+    resolve(shared: Obj$3, props: Obj$3): Promise<{
+        props: Obj$3;
+        metadata: PropsMetadata;
+    }>;
+}
+
+/** The current container when it is a request scope (Http binds HttpRequest only there). */
+declare function requestScope(): Container | undefined;
+declare function currentRequest(): HttpRequest | undefined;
+/** The request's session, or undefined outside a request or when no Session provider is registered. */
+declare function optionalSession(): Session | undefined;
+/** Is this an Inertia visit (X-Inertia header)? */
+declare function isInertiaRequest(request: HttpRequest): boolean;
+/** Laravel's Request::prefetch(): Purpose, Sec-Purpose or X-Moz is 'prefetch'. */
+declare function isPrefetch(request: HttpRequest): boolean;
+/**
+ * A copy of `response` with another status and/or extra headers. Web Responses have a read-only status and may
+ * have immutable headers (Response.redirect()), so this always builds a new one around the same body.
+ */
+declare function rebuild(response: Response, changes: {
+    status?: number;
+    headers?: Record<string, string>;
+}): Response;
+declare function isRedirect(response: Response): boolean;
+
+/** A page component that doesn't exist on disk (inertia.pages.ensure_pages_exist). */
+declare class ComponentNotFoundError extends Error implements OrielError {
+    readonly component: string;
+    readonly kind: "Server";
+    readonly status = 500;
+    constructor(component: string);
+}
+/** An Inertia response outside a request, or a misconfiguration. */
+declare class InertiaError extends Error implements OrielError {
+    readonly kind: "Server";
+    readonly status = 500;
+    constructor(message: string);
+}
+/** An SSR render that failed while inertia.ssr.throw_on_error is on. */
+declare class SsrError extends Error implements OrielError {
+    readonly kind: "Server";
+    readonly status = 500;
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}
+
+type Obj$2 = Record<string, unknown>;
+/** Session keys inertia-laravel uses (Support\SessionKey). */
+declare const SessionKey: {
+    readonly CLEAR_HISTORY: "inertia.clear_history";
+    readonly PRESERVE_FRAGMENT: "inertia.preserve_fragment";
+    readonly FLASH_DATA: "inertia.flash_data";
+};
+type UrlResolver = (request: HttpRequest) => string;
+/** What the factory hands a response: everything decided before the controller returned. */
+interface ResponseSettings {
+    shared: Obj$2;
+    rootView: string;
+    version: () => Promise<string>;
+    encryptHistory: boolean;
+    urlResolver?: UrlResolver;
+    flash: (key: string | Obj$2, value?: unknown) => void;
+}
+/** Path and query of the request, keeping a trailing slash (inertia-laravel's default URL resolver). */
+declare function defaultUrl(request: HttpRequest): string;
+/**
+ * An Inertia page response (inertia-laravel's Response). `C` and `P` carry the component name and props type,
+ * which the generated page-prop types read back.
+ */
+declare class Response$1<C extends string = string, P extends Obj$2 = Obj$2> implements InertiaResponse {
+    #private;
+    readonly component: C;
+    private readonly settings;
+    readonly __component?: C;
+    readonly __props?: P;
+    constructor(component: C, props: P, settings: ResponseSettings);
+    with(key: string | Obj$2, value?: unknown): this;
+    withViewData(key: string | Obj$2, value?: unknown): this;
+    rootView(view: string): this;
+    flash(key: string | Obj$2, value?: unknown): this;
+    /** The page object for this request. */
+    toPage(request: HttpRequest): Promise<InertiaPage>;
+    toResponse(request: unknown): Promise<globalThis.Response>;
+}
+/**
+ * The pages under the page paths, named as inertia() takes them ('Posts/Show'), sorted by name; a page in two paths is
+ * listed once, from the first. A file takes its longest matching extension, so `Show.component.ts` is 'Show'.
+ */
+declare function pageNames(paths: string[], extensions: string[]): Array<{
+    name: string;
+    file: string;
+}>;
+/** Is there a file for `component` ('Posts/Index') under a page path, with one of the extensions? */
+declare function pageExists(component: string, paths: string[], extensions: string[]): boolean;
+
+type Obj$1 = Record<string, unknown>;
+type VersionResolver = string | null | (() => string | null | Promise<string | null>);
+/**
+ * inertia-laravel's ResponseFactory. The application holds one (the root): props shared from a service provider
+ * and the app-wide settings live there. Each request gets a child (scoped): what the HandleInertiaRequests
+ * middleware or a controller shares stays in that request. A child reads through to its root.
+ */
+declare class ResponseFactory implements InertiaFactory {
+    #private;
+    protected readonly app: Application;
+    private readonly parent?;
+    constructor(app: Application, parent?: ResponseFactory | undefined);
+    /** A per-request child of this (root) factory. */
+    forRequest(): ResponseFactory;
+    setRootView(view: string): void;
+    getRootView(): string;
+    share(key: string | Obj$1, value?: unknown): void;
+    shareOnce(key: string, callback: PropCallback): OnceProp;
+    getShared(key?: string, defaultValue?: unknown): unknown;
+    flushShared(): void;
+    version(version: VersionResolver): void;
+    /** The asset version as a string ('' when there is none), like Laravel's `(string) $version`. */
+    getVersion(): Promise<string>;
+    resolveUrlUsing(resolver: UrlResolver | undefined): void;
+    encryptHistory(encrypt?: boolean): void;
+    clearHistory(): void;
+    preserveFragment(): void;
+    optional<T>(callback: PropCallback<T>): OptionalProp<T>;
+    defer<T>(callback: PropCallback<T>, group?: string, options?: {
+        rescue?: boolean;
+    }): DeferProp<T>;
+    always<T>(value: PropValue<T>): AlwaysProp<T>;
+    merge<T>(value: PropValue<T>): MergeProp<T>;
+    deepMerge<T>(value: PropValue<T>): MergeProp<T>;
+    once<T>(callback: PropCallback<T>): OnceProp<T>;
+    scroll<T>(value: PropValue<T>, wrapper?: string, metadata?: (value: T) => ScrollMetadata): ScrollProp<T>;
+    /** Flashes page.flash data for the next Inertia response (stored in the session immediately). */
+    flash(key: string | Obj$1, value?: unknown): this;
+    back(fallback?: string, status?: number): RedirectResponse;
+    /** 409 + X-Inertia-Location for Inertia requests (the client does a full visit), a plain 302 otherwise. */
+    location(url: string): globalThis.Response;
+    render<C extends string, P extends Obj$1 = Record<never, never>>(component: C, props?: P): Response$1<C, P>;
+}
+
+type Obj = Record<string, unknown>;
+/**
+ * The factory for the current context: the request's own (scoped) factory inside a request, else the
+ * application's root factory (a service provider sharing props for every request).
+ */
+declare function inertiaFactory(): ResponseFactory;
+/** inertia('Posts/Index', { posts }) → an Inertia response; inertia() → the factory. */
+declare function inertia(): ResponseFactory;
+declare function inertia<C extends string, P extends Obj = Record<never, never>>(component: C, props?: P): Response$1<C, P>;
+/**
+ * The Inertia facade: Inertia.render(), Inertia.share(), Inertia.defer(), Inertia.flash(...).back(), …
+ * Resolved on every access, so it always talks to the current request's factory.
+ */
+declare const Inertia: ResponseFactory;
+
+/** Markup the view renderer emits as-is (Htmlable, like View's HtmlString; Inertia can't import View). */
+declare class InertiaHtml implements Htmlable {
+    private readonly html;
+    constructor(html: string);
+    toHtml(): string;
+    toString(): string;
+}
+/**
+ * The page as JSON for a <script type="application/json"> element: `/` is escaped (the protocol requires it) and
+ * `<`, `>` are \u-escaped so the JSON can never close the script element. No HTML entities.
+ */
+declare function pageJson(page: InertiaPage): string;
+/** The client-side-rendered mount point: the page script, then the empty root element (Laravel's @inertia). */
+declare function pageMarkup(page: InertiaPage, id?: string): string;
+/** Laravel's @inertiaHead: the SSR head tags, or nothing when the page is rendered in the browser. */
+declare function inertiaHead(page: InertiaPage): Promise<InertiaHtml>;
+/** Laravel's @inertia: the SSR body, else the page script and the empty mount element. */
+declare function inertiaBody(page: InertiaPage, id?: string): Promise<InertiaHtml>;
+
+/** Flat field → first message (or every message with withAllErrors), or bag → fields when named bags are used. */
+type ValidationErrors = Record<string, string | string[]> | Record<string, Record<string, string | string[]>>;
+/**
+ * inertia-laravel's Middleware, the base of the app's HandleInertiaRequests (add it to the `web` group). It shares
+ * the validation errors and your share() props, sets the asset version and root view, and turns responses into
+ * what the Inertia client expects: Vary, 409 on a version change, 303 after PUT/PATCH/DELETE, back() for empty
+ * responses and 409 + X-Inertia-Redirect for redirects with a #fragment.
+ */
+declare class InertiaMiddleware implements Middleware {
+    /** The root view rendered on the first visit: resources/views/app.tsx. */
+    protected rootViewName: string;
+    /** Send every message per field instead of the first one. */
+    protected withAllErrors: boolean;
+    /** Paths (wildcards allowed) rendered without SSR. */
+    protected withoutSsr: string[];
+    protected readonly container: Container;
+    /** The asset version: a hash of app.asset_url, else of public/build/manifest.json, else none. */
+    version(_request: HttpRequest): Promise<string | null>;
+    /** Props shared with every page. Override and spread `await super.share(request)` into your own. */
+    share(request: HttpRequest): Promise<{
+        errors: AlwaysProp<ValidationErrors>;
+    }>;
+    /** Shared once props: sent on the first visit, then kept by the client. */
+    shareOnce(_request: HttpRequest): Promise<Record<string, OnceProp | PropCallback>>;
+    rootView(_request: HttpRequest): string;
+    /** How page.url is built; undefined keeps the default (path + query). */
+    urlResolver(): UrlResolver | undefined;
+    handle(request: HttpRequest, next: Next): Promise<Response>;
+    /** The session's flashed errors ({ [bag]: { field: string[] } }), shaped for the client. */
+    resolveValidationErrors(request: HttpRequest): ValidationErrors;
+    /** inertia.store_previous_url: Inertia GET visits (not prefetches or same-page partial reloads) become previous(). */
+    shouldStoreCurrentUrl(request: HttpRequest, _response: Response): boolean;
+    onEmptyResponse(request: HttpRequest, _response: Response): Promise<Response>;
+    onRedirectWithFragment(_request: HttpRequest, response: Response): Promise<Response>;
+    onVersionChange(request: HttpRequest, _response: Response): Promise<Response>;
+    /** Keeps Inertia flash data for the page the redirect leads to. */
+    protected reflash(session: Session): void;
+}
+
+/** Encrypts the browser history state of the pages behind it (route middleware alias `inertia.encrypt`). */
+declare class EncryptHistory implements Middleware {
+    #private;
+    handle(request: HttpRequest, next: Next): Promise<Response>;
+}
+
+/** Laravel's $request->isPrecognitive(): this request only asks whether its data would pass (a `precognitive` route). */
+declare function isPrecognitive(request: HttpRequest): boolean;
+/**
+ * Laravel's HandlePrecognitiveRequests (the `precognitive` alias): a request with `Precognition: true` (Inertia's
+ * `useForm().validate()`, `<Form validate>`, laravel-precognition) runs the route's action only up to its validation.
+ * Passing answers 204 with `Precognition-Success: true`; failing, the usual 422 with the errors; and nothing after the
+ * validation runs. `Precognition-Validate-Only: name,email` checks those fields only. Every response varies on
+ * `Precognition`, an error's too: the middleware renders what is thrown through it before adding its headers.
+ *
+ * Oriel validates inside the action (`await StoreUserRequest.validate()`, `request().validate({…})`), where Laravel
+ * resolves the FormRequest before calling it, so a precognitive route must validate before it changes anything: what
+ * comes before the validation runs. An action that answers a success without validating is an error (a 500) on any
+ * method but GET and HEAD, which answer 204 as Laravel does; a redirect or an error goes through as it is.
+ */
+declare class HandlePrecognitiveRequests implements Middleware {
+    handle(request: HttpRequest, next: Next): Promise<Response>;
+}
+
+/** Marks `request` as client-rendered when it matches one of `paths` (wildcards allowed). */
+declare function withoutSsr(request: HttpRequest, paths: string[]): void;
+declare function isExcludedFromSsr(request: HttpRequest): boolean;
+
+/**
+ * Binds the Inertia factory (one root factory, plus a scoped child per request), the SSR gateway and the
+ * `inertia.encrypt` and `precognitive` middleware aliases, merges config/inertia defaults and registers the inertia:*
+ * commands.
+ */
+declare class InertiaServiceProvider extends ServiceProvider {
+    register(): void;
+    boot(): void;
+}
+
+/** Why an SSR render failed (inertia-laravel's SsrRenderFailed event payload). */
+interface SsrFailure {
+    page: InertiaPage;
+    error: string;
+    type: string;
+    hint?: string;
+    browserApi?: string;
+    stack?: string;
+    sourceLocation?: string;
+}
+/** The event name dispatched through the EventDispatcher when an SSR render fails. */
+declare const SSR_RENDER_FAILED = "inertia.ssr.failed";
+/**
+ * inertia-laravel's HttpGateway. Production: POST the page to {inertia.ssr.url}/render. While Vite runs hot
+ * (public/hot exists): POST to {hot url}/__inertia_ssr, which @inertiajs/vite serves. Any failure falls back to
+ * client-side rendering (undefined), unless inertia.ssr.throw_on_error is on.
+ */
+declare class HttpGateway implements InertiaSsrGateway {
+    #private;
+    protected readonly app: Application;
+    constructor(app: Application);
+    disable(condition?: boolean | (() => boolean)): void;
+    /** Paths (wildcards allowed) never rendered on the server. */
+    except(paths: string | string[]): void;
+    dispatch(page: InertiaPage): Promise<InertiaSsrResponse | undefined>;
+    /** GET {inertia.ssr.url}/health: any 2xx is healthy. */
+    isHealthy(): Promise<boolean>;
+    productionUrl(): string;
+    /** inertia.ssr.hot_url, else the Vite dev server URL in public/hot; undefined when Vite isn't running. */
+    hotUrl(): string | undefined;
+    /** inertia.ssr.bundle, else bootstrap/ssr/{ssr,app}.{js,mjs}, else public/js/{ssr,app}.js (BundleDetector). */
+    bundle(): string | undefined;
+    enabled(request: HttpRequest | undefined): boolean;
+}
+
+/** One named route as the client's route() needs it. */
+interface RouteTableEntry {
+    uri: string;
+    methods: string[];
+}
+interface RouteParameterInfo {
+    name: string;
+    optional: boolean;
+    /** The binding column from '{post:slug}'. */
+    field: string | undefined;
+}
+/** '{post}', '{post?}', '{post:slug}' in URI order. */
+declare function routeParameters(uri: string): RouteParameterInfo[];
+/** Every named route, sorted by name, minus the names matching `except` (wildcards allowed: 'admin.*'). */
+declare function routeTable(routes: readonly Route[], except?: string[]): Record<string, RouteTableEntry>;
+/**
+ * resources/js/oriel/routes.ts: the route table the browser's route() reads, and the RouteList augmentation that
+ * types route names and parameters.
+ */
+declare function renderRoutesModule(table: Record<string, RouteTableEntry>, clientModule?: string): string;
+/**
+ * types/routes.d.ts: the route names for the server's route(), redirect().route() and UrlGenerator. The bundled
+ * @orieljs/framework declares RouteList in both entry points, so both are augmented.
+ */
+declare function renderServerRouteTypes(table: Record<string, RouteTableEntry>): string;
+
+/** app/Http/Middleware/HandleInertiaRequests.ts, written by inertia:middleware. */
+declare const MIDDLEWARE_STUB = "import { InertiaMiddleware } from '@orieljs/framework'\nimport type { HttpRequest } from '@orieljs/framework/contracts'\n\nexport class {{ class }} extends InertiaMiddleware {\n  /** The root view loaded on the first page visit: resources/views/app.tsx. */\n  protected override rootViewName = 'app'\n\n  /** Props shared with every page (typed for the pages by `oriel inertia:types`). */\n  override async share(request: HttpRequest) {\n    return {\n      ...(await super.share(request)),\n    }\n  }\n}\n";
+/** The page-type generator lives in @orieljs/vite (it needs the TypeScript compiler, a dev dependency). */
+interface PageTypesModule {
+    generatePageTypes(options: {
+        root: string;
+        output: string;
+        tsconfig?: string;
+    }): Promise<{
+        output: string;
+        pages: number;
+        warnings: string[];
+    }>;
+}
+interface InertiaCommandOptions {
+    /** Replaces the dynamic import of @orieljs/vite/types (tests). */
+    pageTypes?: () => Promise<PageTypesModule | undefined>;
+    /** Replaces child_process.spawn for inertia:start-ssr (tests). */
+    spawn?: typeof spawn;
+}
+/** route:types, inertia:types, inertia:middleware, inertia:start-ssr, inertia:stop-ssr and inertia:check-ssr. */
+declare function registerInertiaCommands(kernel: ConsoleKernel, app: Application, gateway: HttpGateway, options?: InertiaCommandOptions): void;
+
+/**
+ * Types that turn what a controller passes to inertia() into what the page receives: prop types unwrapped,
+ * callbacks resolved, models, paginators and dates serialized the way JSON.stringify(toJSON()) does.
+ * The generated page-prop types (resources/js/oriel/pages.d.ts) are built from these.
+ */
+/** Deferred and optional props are missing on the first load, so they are optional keys. */
+interface MaybeMissingProp {
+    readonly kind: 'defer' | 'optional';
+}
+/** The value inside an Inertia prop type, or the value itself. */
+type Unwrap<V> = V extends {
+    readonly kind: string;
+    readonly __value?: infer T;
+} ? T : V;
+type Simplify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+/** Keys that may be absent: deferred/optional props and values that can be undefined (JSON drops them). */
+type OptionalKeys<T> = {
+    [K in keyof T]-?: T[K] extends MaybeMissingProp ? K : undefined extends T[K] ? K : never;
+}[keyof T];
+interface LengthAwarePage<T> {
+    current_page: number;
+    data: T[];
+    first_page_url: string;
+    from: number | null;
+    last_page: number;
+    last_page_url: string;
+    links: Array<{
+        url: string | null;
+        label: string;
+        active: boolean;
+    }>;
+    next_page_url: string | null;
+    path: string;
+    per_page: number;
+    prev_page_url: string | null;
+    to: number | null;
+    total: number;
+}
+interface SimplePage<T> {
+    current_page: number;
+    current_page_url: string;
+    data: T[];
+    first_page_url: string;
+    from: number | null;
+    next_page_url: string | null;
+    path: string;
+    per_page: number;
+    prev_page_url: string | null;
+    to: number | null;
+}
+interface CursorPage<T> {
+    data: T[];
+    path: string;
+    per_page: number;
+    next_cursor: string | null;
+    next_page_url: string | null;
+    prev_cursor: string | null;
+    prev_page_url: string | null;
+}
+/** An object after serialization: keys typed one by one, optional where the value may be missing. */
+type SerializedObject<T> = Simplify<{
+    [K in Exclude<keyof T, OptionalKeys<T>> as K extends string ? K : never]: Serialized<Unwrap<T[K]>>;
+} & {
+    [K in OptionalKeys<T> as K extends string ? K : never]?: Serialized<Exclude<Unwrap<T[K]>, undefined>>;
+}>;
+/** A model's generated column types (types/models.d.ts declares `$attributes`), or never for anything else. */
+type ModelAttributes<T> = T extends {
+    $attributes?: infer A;
+} ? (unknown extends A ? never : NonNullable<A>) : never;
+/** What a prop value looks like on the page. */
+type Serialized<T> = T extends string | number | boolean | null ? T : T extends undefined | symbol | bigint ? never : T extends Date ? string : T extends {
+    readonly kind: string;
+    readonly __value?: infer V;
+} ? Serialized<V> : T extends (...args: never[]) => infer R ? Serialized<Awaited<R>> : T extends PromiseLike<infer R> ? Serialized<R> : T extends {
+    items(): Array<infer I>;
+    total(): number;
+    lastPage(): number;
+} ? LengthAwarePage<Serialized<I>> : T extends {
+    items(): Array<infer I>;
+    getCursorName(): string;
+} ? CursorPage<Serialized<I>> : T extends {
+    items(): Array<infer I>;
+    getPageName(): string;
+} ? SimplePage<Serialized<I>> : T extends {
+    toJSON(): infer J;
+} ? ModelAttributes<T> extends never ? Serialized<J> : SerializedObject<ModelAttributes<T>> : T extends ReadonlyArray<infer I> ? Array<Serialized<I>> : T extends object ? SerializedObject<T> : unknown;
+/** The props of component `C` from a controller method's return type `R` (a union when it returns several). */
+type PagePropsFrom<R, C extends string> = Awaited<R> extends infer Result ? Result extends {
+    readonly component: C;
+    readonly __props?: infer P;
+} ? SerializedObject<P> : never : never;
+/** The shared props of the app's HandleInertiaRequests middleware (the resolved share() result). */
+type SharedPropsFrom<M> = M extends {
+    share(...args: never[]): infer R;
+} ? SerializedObject<Awaited<R>> : Record<never, never>;
+
+export { AlwaysProp, ComponentNotFoundError, type CursorPage, DeferProp, EncryptHistory, HandlePrecognitiveRequests, Header, HttpGateway, Inertia, type InertiaCommandOptions, InertiaError, InertiaHtml, InertiaMiddleware, Response$1 as InertiaPageResponse, ResponseFactory as InertiaResponseFactory, InertiaServiceProvider, type LengthAwarePage, MIDDLEWARE_STUB, MergeProp, MergeableProp, OnceProp, OptionalProp, type PagePropsFrom, type PageTypesModule, Prop, type PropValue, type PropsMetadata, PropsResolver, type PropsResolverOptions, type ResponseSettings, type RouteParameterInfo, type RouteTableEntry, SSR_RENDER_FAILED, type ScrollMetadata, ScrollProp, type Serialized, type SerializedObject, SessionKey, type SharedPropsFrom, type SimplePage, SsrError, type SsrFailure, type UrlResolver, type ValidationErrors, currentRequest, defaultUrl, inertia, inertiaBody, inertiaFactory, inertiaHead, isExcludedFromSsr, isInertiaRequest, isPrecognitive, isPrefetch, isProp, isRedirect, optionalSession, pageExists, pageJson, pageMarkup, pageNames, parseList, rebuild, registerInertiaCommands, renderRoutesModule, renderServerRouteTypes, requestScope, routeParameters, routeTable, scrollMetadataFrom, secondsUntil, withoutSsr };