@zerotal/inertia 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,17 @@
+# Changelog — @zerotal/inertia
+
+All notable changes to this package are documented here. The format is
+based on [Keep a Changelog](https://keepachangelog.com/); this package
+follows the Zerotal monorepo's unified versioning.
+
+**Maturity: `beta`**
+
+## [Unreleased]
+
+## [1.0.0] — 2026-08-05
+
+_First public release._
+
+### Notes
+
+- Conforms to the Zerotal package conventions (provider in `src/provider/`, PascalCase config factory, `ZerotalError`-based errors, test coverage).

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Zerotal
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,140 @@
+# @zerotal/inertia
+
+> A native, Bun-powered Inertia.js server adapter for React/Vue SPAs without a separate API.
+
+Lets you build single-page apps using server-side routing and controllers — no
+separate API layer, no client-side router. Controllers return Inertia page
+responses; the stock `@inertiajs/react` / `@inertiajs/vue3` clients render the
+matching component. Ships full Inertia v3 support: controller-less page routes,
+auto-merged shared props, asset versioning, the data-props layer (partial reloads,
+`optional`/`defer`/`merge`), history encryption, precognition, and optional
+streaming SSR. Flash, errors, and old input are read from the request's session
+when the app runs [`@zerotal/session`](../session/README.md) — no hard
+dependency between the two packages.
+
+Part of the [Zerotal](../../README.md) framework. Requires **Bun ≥ 1.3.14**.
+
+## Installation
+
+```bash
+bun add @zerotal/inertia
+# plus the client of your choice:
+bun add @inertiajs/react react react-dom   # React
+# or
+bun add @inertiajs/vue3 vue                # Vue
+```
+
+## Setup
+
+Register the provider in `bootstrap/providers.ts`:
+
+```ts
+import { InertiaProvider } from "@zerotal/inertia";
+
+export default [InertiaProvider];
+```
+
+`InertiaProvider` loads the HTML template and asset version at boot,
+auto-registers `InertiaMiddleware` (you do **not** add it to `.use()` manually),
+and registers the `POST /__ssr` endpoint when `ssr: true`. Configure it in
+`config/inertia.ts`:
+
+```ts
+// config/inertia.ts
+import { InertiaConfig } from "@zerotal/inertia";
+import { env } from "@zerotal/core";
+
+export default InertiaConfig({
+  htmlTemplate: "./resources/app.html", // must contain <!-- @inertia -->
+  version: env("ASSET_VERSION", "1"), // cache-bust string; bump on each deploy
+  assetsUrl: "/assets",
+  ssr: false, // set true to enable POST /__ssr
+});
+```
+
+## Usage
+
+Return a page from any controller action. `inertia()` reads the active request
+from context (no `ctx`/`http` argument) and sets the response as a side effect, so
+the action returns `Promise<void>` — always `return inertia(...)`:
+
+```ts
+import type { Context } from "@zerotal/core";
+import { inertia } from "@zerotal/inertia";
+import { Post } from "../models/Post.ts";
+
+export class DashboardController {
+  async index({ http }: Context): Promise<void> {
+    const posts = await Post.query().latest().limit(5).get();
+    return inertia("Dashboard", { posts }); // → resources/pages/Dashboard.tsx
+  }
+}
+```
+
+Control which props are sent and when with the prop wrappers:
+
+```ts
+import { inertia, optional, defer, merge } from "@zerotal/inertia";
+
+return inertia("Users/Index", {
+  users: () => User.all(), // lazy — only evaluated when sent
+  roles: optional(() => Role.all()), // only on a partial reload that asks for it
+  stats: defer(() => computeStats()), // loaded after first paint
+  feed: merge(() => Post.paginate(15, page)), // appended on "load more"
+});
+```
+
+Render controller-less pages straight from a route, and send external/full-page
+visits via the unified facade:
+
+```ts
+import { Router } from "@zerotal/core";
+import { Inertia } from "@zerotal/inertia";
+
+Router.inertia("/about", "About/Index"); // no props
+Router.inertia("/admin", "Admin/Dashboard", [AuthMiddleware]); // middleware shorthand
+
+return Inertia.location("https://billing.stripe.com/session/abc"); // 409 / 302
+```
+
+Register custom shared props once and they merge into every page:
+
+```ts
+import { Inertia } from "@zerotal/inertia";
+
+Inertia.share({
+  appName: "Acme",
+  year: () => new Date().getFullYear(), // evaluated per request
+  flags: Inertia.optional(() => FeatureFlag.all()),
+});
+```
+
+## Exports
+
+- `inertia`, `inertiaStream`, `buildPageObject` — render page responses.
+- `Inertia` — unified facade for the Inertia protocol
+  (`render`, `share`, `optional`, `defer`, `merge`, `location`, …).
+- `inertiaRoute` / `Router.inertia()` — controller-less page routes.
+- `InertiaProvider`, `InertiaMiddleware`, `PrecognitionMiddleware` — wiring.
+- `sharedProps`, `share` — shared-props registry.
+- Prop wrappers + factories: `InertiaProp`, `OptionalProp`, `AlwaysProp`,
+  `DeferProp`, `MergeProp`, `InfiniteScrollProp`, `optional`, `lazy`, `always`,
+  `defer`, `merge`, `deepMerge`, `scroll`; plus `resolveProps`.
+- `encryptHistory`, `clearHistory`, `setHistoryEncryptionDefault` — history encryption.
+- `location` — external / fragment redirects.
+- `assetVersion`, `setAssetVersion`, `generatePageRegistry`, `detectVuePlugin`,
+  `SsrHandler` — versioning, build, and SSR utilities.
+- `InertiaConfig` / `InertiaConfigShape` — config factory and shape.
+- Types: `PageObject`, `InertiaProviderOptions`, `PropFactory`, `MergeConfig`,
+  `PaginatorLike`, `ScrollConfig`, `ResolvedPage`.
+- Errors: `InertiaError`, `InertiaTemplateNotLoadedError`, `InvalidComponentError`.
+
+## Documentation
+
+- [Inertia overview](../../docs/inertia/index.md)
+- [Rendering Pages](../../docs/inertia/rendering.md)
+- [Props](../../docs/inertia/props.md)
+- [Middleware & Versioning](../../docs/inertia/middleware.md)
+- [Server-Side Rendering](../../docs/inertia/ssr.md)
+- [CLI & Build](../../docs/inertia/build.md)
+- [References](../../docs/inertia/references.md)

package/package.json

@@ -0,0 +1,80 @@
+{
+  "name": "@zerotal/inertia",
+  "version": "1.0.0",
+  "license": "MIT",
+  "maturity": "beta",
+  "private": false,
+  "type": "module",
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "files": [
+    "CHANGELOG.md",
+    "src",
+    "!src/**/*.test.ts",
+    "!src/**/*.test.tsx",
+    "!src/**/*.spec.ts",
+    "!src/**/__fixtures__/**"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "bun": ">=1.3.14"
+  },
+  "sideEffects": [
+    "./src/augment.ts"
+  ],
+  "scripts": {
+    "test": "bun test",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@zerotal/core": "1.0.0"
+  },
+  "peerDependencies": {
+    "react": "^18 || ^19",
+    "react-dom": "^18 || ^19",
+    "vue": "^3",
+    "@inertiajs/react": "^1 || ^2",
+    "@inertiajs/vue3": "^1 || ^2"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    },
+    "react-dom": {
+      "optional": true
+    },
+    "vue": {
+      "optional": true
+    },
+    "@inertiajs/react": {
+      "optional": true
+    },
+    "@inertiajs/vue3": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "react": "^19.2.7",
+    "react-dom": "^19.2.7",
+    "typescript": "^5.8.0"
+  },
+  "description": "Inertia.js adapter for Zerotal — server-driven React/Vue single-page apps.",
+  "keywords": [
+    "zerotal",
+    "bun",
+    "typescript",
+    "framework"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/zerotaldev/zerotal.git",
+    "directory": "packages/inertia"
+  },
+  "homepage": "https://github.com/zerotaldev/zerotal/tree/main/packages/inertia#readme",
+  "bugs": "https://github.com/zerotaldev/zerotal/issues"
+}

package/src/PageRegistry.ts

@@ -0,0 +1,101 @@
+/**
+ * Scans the configured pages directory (default `resources/js/pages`) for
+ * `**\/*.tsx` using Bun.Glob and generates `resources/js/pages.generated.ts` —
+ * a file of dynamic import thunks.
+ *
+ * Bun.build with splitting:true recognises dynamic import() calls and
+ * automatically creates a separate .js chunk per page component.
+ * Users download only the chunk for the page they are visiting.
+ *
+ * The directory is configurable via `inertia.pagesDir` in config/inertia.ts.
+ * Import paths in the generated file are computed relative to the generated
+ * file's own location (`resources/js/`), so any pages directory works.
+ *
+ * Run via: bun zt inertia:build
+ * Or automatically during InertiaProvider.onBooted() in production.
+ */
+import { config } from "@zerotal/core";
+import { frameworkLog } from "@zerotal/core/logger";
+import { relative } from "node:path";
+import { DEFAULT_PAGES_DIR } from "./config.ts";
+
+// The generated registry always lives alongside app.tsx so it can be imported
+// from there. Import specifiers are resolved relative to this directory.
+const GENERATED_DIR = "resources/js";
+const GENERATED_FILE = `${GENERATED_DIR}/pages.generated.ts`;
+
+/**
+ * Scan the pages directory and (re)write `resources/js/pages.generated.ts`, a map of
+ * page name → dynamic `import()` thunk that `Bun.build({ splitting: true })` turns into
+ * one lazy-loaded chunk per page. Called by the `inertia:build` / `make:page` commands
+ * and by `InertiaProvider` at boot in production.
+ *
+ * @param cwd - Project root to scan and write relative to. Defaults to `process.cwd()`.
+ * @param pagesDir - Pages directory relative to `cwd`. Defaults to the `inertia.pagesDir` config (`resources/js/pages`).
+ * @returns Resolves once the registry file has been written.
+ * @internal Framework scaffolding; not called from application code.
+ */
+export async function generatePageRegistry(
+  cwd = process.cwd(),
+  pagesDir: string = config.safe("inertia.pagesDir", DEFAULT_PAGES_DIR),
+): Promise<void> {
+  // Normalise to a cwd-relative POSIX path without a trailing slash.
+  const dir = pagesDir.replace(/\\/g, "/").replace(/\/+$/, "");
+
+  // Import base is the path from the generated file's directory to the pages
+  // directory, e.g. 'resources/js' → 'resources/js/pages' yields 'pages',
+  // and 'resources/js' → 'resources/pages' yields '../pages'.
+  const importBase = relative(GENERATED_DIR, dir).replace(/\\/g, "/") || ".";
+
+  // Match both React/JSX pages (.tsx) and Vue Single-File Components (.vue).
+  const glob = new Bun.Glob(`${dir}/**/*.{tsx,vue}`);
+  const thunks: string[] = [];
+
+  for await (const file of glob.scan({ cwd })) {
+    const normalised = file.replace(/\\/g, "/"); // normalise Windows backslashes
+
+    // 'resources/js/pages/Users/Index.tsx' → 'Users/Index' (extension dropped
+    // for the registry key, but preserved in the import specifier below).
+    const rel = normalised.slice(dir.length + 1); // strip the pages directory prefix
+    const name = rel.replace(/\.(tsx|vue)$/, "");
+
+    // Build a relative specifier (with its real extension); ensure a leading
+    // './' for same/child dirs so Bun resolves it and the .vue loader can fire.
+    const importPath = `${importBase}/${rel}`;
+    const specifier = importPath.startsWith(".") ? importPath : `./${importPath}`;
+
+    // Quote the key only when it isn't a bare identifier — a nested page yields
+    // `Users/Index`, which has to stay quoted to be valid.
+    const key = /^[A-Za-z_$][\w$]*$/.test(name) ? name : JSON.stringify(name);
+
+    // Dynamic thunk — NOT `import X from '...'`
+    // Bun splits each of these into a separate .js chunk automatically
+    thunks.push(`  ${key}: () => import(${JSON.stringify(specifier)}),`);
+  }
+
+  if (thunks.length === 0) {
+    frameworkLog("inertia").warn("No page components found", { dir });
+  }
+
+  const content = [
+    "// Auto-generated by @zerotal/inertia — do not edit manually.",
+    "// Regenerate with: bun zt inertia:build",
+    "//",
+    "// IMPORTANT: These are dynamic import THUNKS, not static imports.",
+    "// Bun.build with splitting:true creates one .js chunk per page.",
+    "// Converting to static imports will bundle ALL pages into app.js.",
+    "",
+    "export const pages: Record<string, () => Promise<{ default: unknown }>> = {",
+    ...thunks,
+    "};",
+    // Trailing newline: the file is written on every dev rebuild, and without it
+    // a formatter in the app would rewrite it right back, forever.
+    "",
+  ].join("\n");
+
+  await Bun.write(`${cwd}/${GENERATED_FILE}`, content);
+
+  frameworkLog("inertia").info(`Generated page registry: ${thunks.length} pages`, {
+    pages: thunks.length,
+  });
+}

package/src/SharedProps.ts

@@ -0,0 +1,83 @@
+import { RequestContext } from "@zerotal/core";
+import { always } from "./props/PropTypes.ts";
+import { registeredShared } from "./share.ts";
+
+/**
+ * Data automatically merged into every Inertia page's props.
+ * Controllers never need to pass auth or flash — it's always there.
+ *
+ * `errors` is wrapped in `always()` so it survives partial reloads (the Inertia client always
+ * expects an `errors` bag). When the request carries an `X-Inertia-Error-Bag` header, errors are
+ * namespaced under that bag. Other shared props (auth/flash/old) are normal props and are therefore
+ * subject to partial-reload `only`/`except` filtering, matching Inertia's semantics.
+ *
+ * @returns The built-in shared props (`auth`, `flash`, `errors`, `old`) merged with anything registered via {@link share}.
+ * @internal Called by {@link buildPageObject} to seed every page; app code registers extras via `Inertia.share()`.
+ */
+export function sharedProps(): Record<string, unknown> {
+  const ctx = RequestContext.get();
+  // Session may not exist outside HTTP context — use optional chaining
+  const session = (
+    ctx as unknown as {
+      session?: { get<T>(key: string): T | undefined };
+    }
+  ).session;
+
+  // `user` is set on the context by the auth/session middleware (typed via auth's augment).
+  const ctxUser = (ctx as unknown as { user?: unknown }).user;
+
+  const rawErrors = session?.get<Record<string, string>>("errors") ?? {};
+  const errorBag = ctx.request.headers.get("X-Inertia-Error-Bag");
+  const errors = errorBag ? { [errorBag]: rawErrors } : rawErrors;
+
+  return {
+    auth: {
+      // Serialize only scalar properties — model instances with un-loaded @hasMany
+      // relations will throw RelationNotLoadedError when JSON.stringify tries
+      // to access the relation getter. A plain object is always safe to serialize.
+      user: ctxUser ? _serializeUser(ctxUser as Record<string | symbol, unknown>) : null,
+    },
+    flash: {
+      success: session?.get<string>("success") ?? null,
+      error: session?.get<string>("error") ?? null,
+    },
+    errors: always(errors),
+    old: session?.get<Record<string, unknown>>("old") ?? {},
+    // App-registered shared props via Inertia.share(...).
+    ...registeredShared(),
+  };
+}
+
+/**
+ * Convert an AuthenticatedUser (which may be a BaseModel instance) into a
+ * plain object containing only scalar values. This prevents JSON.stringify
+ * from triggering relation property getters that throw when not eager-loaded.
+ *
+ * @internal
+ */
+function _serializeUser(user: Record<string | symbol, unknown>): Record<string, unknown> {
+  // Prefer the model's own toJSON(). That is the method which honours `static hidden`
+  // (password, rememberToken), skips `_`-prefixed internals such as `_original` — the
+  // untouched DB row — and applies casts. Walking Object.keys() instead meant every
+  // authenticated Inertia response embedded the user's password hash and remember token in the
+  // page JSON, where it was also cached in history.state.
+  if (typeof user["toJSON"] === "function") {
+    const json = (user as { toJSON(): unknown }).toJSON();
+    if (json && typeof json === "object") return json as Record<string, unknown>;
+  }
+
+  // Fallback for a plain object (a test double, or an app that does not use the ORM).
+  const out: Record<string, unknown> = {};
+  for (const key of Object.keys(user)) {
+    if (key.startsWith("_")) continue;
+    try {
+      const val = user[key];
+      // Skip functions — those are methods, not data.
+      if (typeof val === "function") continue;
+      out[key] = val;
+    } catch {
+      // Property getter throws (e.g. un-loaded @hasMany relation) — skip silently
+    }
+  }
+  return out;
+}

package/src/SsrHandler.ts

@@ -0,0 +1,145 @@
+import { config, safeEqual, type HttpContext } from "@zerotal/core";
+import { Log } from "@zerotal/core/logger";
+import { DEFAULT_PAGES_DIR } from "./config.ts";
+import { resolvePageModule, renderInertiaPage } from "./ssr/renderPage.ts";
+
+/** Header carrying the shared secret when the SSR renderer runs off-box. */
+export const SSR_SECRET_HEADER = "x-inertia-ssr-secret";
+
+/**
+ * Loopback addresses, in the forms Bun reports them.
+ *
+ * Upstream Inertia runs SSR as a separate process on a private port precisely because this
+ * endpoint takes an arbitrary component name and a props bag and does real rendering work
+ * with them. Zerotal serves it from the same process, so the equivalent boundary has to be
+ * enforced in the handler.
+ */
+const LOOPBACK = new Set(["127.0.0.1", "::1", "::ffff:127.0.0.1", "localhost"]);
+
+interface SsrRequestBody {
+  component: string;
+  props: Record<string, unknown>;
+  url: string;
+}
+
+interface SsrResponseBody {
+  body: string;
+  head: string[];
+}
+
+/**
+ * POST /__ssr — Inertia server-side rendering endpoint.
+ *
+ * Accepts the Inertia SSR wire format: { component, props, url }
+ * Returns { body, head } — the rendered HTML string and any head injections.
+ *
+ * The component is resolved from <cwd>/<pagesDir>/<component>.{vue,tsx}
+ * (pagesDir defaults to the configured `inertia.pagesDir`, i.e. resources/js/pages)
+ * and rendered with the matching framework runtime — Vue (`@inertiajs/vue3` +
+ * `vue/server-renderer`) for `.vue` files, React (`react-dom/server`) for `.tsx`.
+ *
+ * App authors never instantiate this directly — `InertiaProvider` registers the
+ * route when SSR is enabled. Turn it on by setting `ssr: true` in `config/inertia.ts`,
+ * and install the server renderer for the framework(s) in use.
+ *
+ * @example
+ * ```ts
+ * // config/inertia.ts
+ * export default InertiaConfig({ ssr: true }); // registers POST /__ssr
+ * ```
+ */
+export class SsrHandler {
+  private readonly _pagesDir: string;
+
+  /**
+   * @param options - `pagesDir` overrides where page components are resolved from; defaults to `<cwd>/<inertia.pagesDir>`.
+   */
+  constructor(options: { pagesDir?: string } = {}) {
+    this._pagesDir =
+      options.pagesDir ?? `${process.cwd()}/${config.safe("inertia.pagesDir", DEFAULT_PAGES_DIR)}`;
+  }
+
+  /**
+   * Handle a `POST /__ssr` request: validate the `{ component, props, url }` body,
+   * reject path traversal, render the page with the matching framework runtime, and
+   * respond with `{ body, head }` (or a `4xx`/`500` JSON error).
+   *
+   * @param http - The request context; its `response` is set as a side effect.
+   * @internal Invoked by the router, not called directly.
+   */
+  async handle(http: HttpContext): Promise<void> {
+    if (!SsrHandler.isAuthorized(http)) {
+      http.response = Response.json({ message: "Not found." }, { status: 404 });
+      return;
+    }
+
+    let body: SsrRequestBody;
+    try {
+      body = (await http.request.json()) as SsrRequestBody;
+    } catch {
+      http.response = Response.json({ message: "Invalid JSON body." }, { status: 400 });
+      return;
+    }
+
+    const { component, props, url } = body;
+
+    if (!component) {
+      http.response = Response.json({ message: "component is required." }, { status: 422 });
+      return;
+    }
+
+    // Reject path traversal
+    if (component.includes("..") || component.startsWith("/")) {
+      http.response = Response.json({ message: "Invalid component name." }, { status: 422 });
+      return;
+    }
+
+    try {
+      // Detect the framework from the page file (.vue → Vue, .tsx → React) and
+      // render with the matching runtime.
+      const { modPath, framework } = await resolvePageModule(this._pagesDir, component);
+      const { body, head } = await renderInertiaPage({ component, props, url }, modPath, framework);
+
+      const response: SsrResponseBody = { body, head };
+      http.response = Response.json(response);
+    } catch (err) {
+      // The detail goes to the log, not the response. Reflecting it made the endpoint a
+      // filesystem-path oracle: a render failure named the absolute module path it tried.
+      // Logging is best-effort — an error path that can itself throw is worse than the
+      // leak it replaced, and the logger is container-resolved.
+      const detail = (err as Error).message ?? String(err);
+      try {
+        Log.error("[Inertia] SSR render failed", { component, error: detail });
+      } catch {
+        console.error(`[Inertia] SSR render failed for "${component}": ${detail}`);
+      }
+      http.response = Response.json({ message: "SSR render failed." }, { status: 500 });
+    }
+  }
+
+  /**
+   * Whether this request may reach the SSR renderer.
+   *
+   * Two ways in, and nothing else:
+   * - the peer is on loopback — the normal case, where the SSR client is the app's own
+   *   Node/Bun renderer talking to itself;
+   * - the request carries {@link SSR_SECRET_HEADER} matching `inertia.ssrSecret`, for a
+   *   renderer running on another host.
+   *
+   * Everyone else gets a 404 rather than a 403, because whether this route exists is not
+   * information a stranger needs. Without the check the endpoint was unauthenticated,
+   * unthrottled, and cheap CPU amplification for anyone who found it.
+   *
+   * @param http - The request context.
+   * @returns `true` when the request is permitted.
+   */
+  static isAuthorized(http: HttpContext): boolean {
+    const secret = config.safe("inertia.ssrSecret", "");
+    if (secret) {
+      const presented = http.request.headers.get(SSR_SECRET_HEADER);
+      if (presented && safeEqual(presented, secret)) return true;
+    }
+    const ip = http.ip();
+    return ip !== undefined && ip !== null && LOOPBACK.has(ip);
+  }
+}

package/src/augment.ts

@@ -0,0 +1,22 @@
+import type { MiddlewareClass, RouteRegistration } from "@zerotal/core";
+
+declare module "@zerotal/core" {
+  interface RouterMacros {
+    /**
+     * Register a GET route that renders an Inertia page without a controller.
+     *
+     * @example
+     * Router.inertia('/about', 'About/Index');
+     * Router.inertia('/home',  'Home/Index', { greeting: 'Hello' });
+     * Router.inertia('/admin', 'Admin/Dashboard', [AuthMiddleware]);
+     */
+    inertia(
+      path: string,
+      component: string,
+      props?: Record<string, unknown> | MiddlewareClass[],
+      middleware?: MiddlewareClass[],
+    ): RouteRegistration;
+  }
+}
+
+export {};