@adonisjs/inertia 4.0.0-next.1 → 4.0.0-next.11

package/build/inertia_manager-Di3J3hSG.js

@@ -0,0 +1,403 @@
+import { t as InertiaHeaders } from "./headers-DafWEpBh.js";
+import { t as debug_default } from "./debug-CBMTuPUm.js";
+import "node:module";
+import { createHash } from "node:crypto";
+import { serialize } from "@adonisjs/core/transformers";
+import { pathToFileURL } from "node:url";
+var __defProp = Object.defineProperty;
+var __export = (all, symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var symbols_exports = /* @__PURE__ */ __export({
+	ALWAYS_PROP: () => ALWAYS_PROP,
+	DEEP_MERGE: () => DEEP_MERGE,
+	DEFERRED_PROP: () => DEFERRED_PROP,
+	OPTIONAL_PROP: () => OPTIONAL_PROP,
+	TO_BE_MERGED: () => TO_BE_MERGED
+});
+const ALWAYS_PROP = Symbol.for("ALWAYS_PROP");
+const OPTIONAL_PROP = Symbol.for("OPTIONAL_PROP");
+const TO_BE_MERGED = Symbol.for("TO_BE_MERGED");
+const DEFERRED_PROP = Symbol.for("DEFERRED_PROP");
+const DEEP_MERGE = Symbol.for("DEEP_MERGE");
+function isObject(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function defer(fn, group = "default") {
+	return {
+		group,
+		compute: fn,
+		merge() {
+			return merge(this);
+		},
+		[DEFERRED_PROP]: true
+	};
+}
+function optional(fn) {
+	return {
+		compute: fn,
+		[OPTIONAL_PROP]: true
+	};
+}
+function always(value) {
+	return {
+		value,
+		[ALWAYS_PROP]: true
+	};
+}
+function merge(value) {
+	return {
+		value,
+		[TO_BE_MERGED]: true,
+		[DEEP_MERGE]: false
+	};
+}
+function deepMerge(value) {
+	return {
+		value,
+		[TO_BE_MERGED]: true,
+		[DEEP_MERGE]: true
+	};
+}
+function isDeferredProp(propValue) {
+	return DEFERRED_PROP in propValue;
+}
+function isMergeableProp(propValue) {
+	return TO_BE_MERGED in propValue;
+}
+function isAlwaysProp(propValue) {
+	return ALWAYS_PROP in propValue;
+}
+function isOptionalProp(propValue) {
+	return OPTIONAL_PROP in propValue;
+}
+async function unpackPropValue(value, containerResolver) {
+	return serialize(value, containerResolver);
+}
+async function buildStandardVisitProps(pageProps, containerResolver) {
+	const mergeProps = [];
+	const deepMergeProps = [];
+	const newProps = {};
+	const deferredProps = {};
+	const unpackedValues = [];
+	for (const [key, value] of Object.entries(pageProps)) if (isObject(value)) {
+		if (isDeferredProp(value)) {
+			deferredProps[value.group] = deferredProps[value.group] ?? [];
+			deferredProps[value.group].push(key);
+			continue;
+		}
+		if (isOptionalProp(value)) continue;
+		if (isAlwaysProp(value)) {
+			unpackedValues.push({
+				key,
+				value: value.value
+			});
+			continue;
+		}
+		if (isMergeableProp(value)) {
+			if (value[DEEP_MERGE]) deepMergeProps.push(key);
+			else mergeProps.push(key);
+			if (isObject(value.value) && isDeferredProp(value.value)) {
+				deferredProps[value.value.group] = deferredProps[value.value.group] ?? [];
+				deferredProps[value.value.group].push(key);
+				unpackedValues.push({
+					key,
+					value: value.value.compute
+				});
+			} else unpackedValues.push({
+				key,
+				value: value.value
+			});
+			continue;
+		}
+		unpackedValues.push({
+			key,
+			value
+		});
+	} else {
+		if (typeof value === "function") {
+			unpackedValues.push({
+				key,
+				value
+			});
+			continue;
+		}
+		newProps[key] = value;
+	}
+	await Promise.all(unpackedValues.map(async ({ key, value }) => {
+		if (typeof value === "function") return Promise.resolve(value()).then((r) => unpackPropValue(r, containerResolver)).then((jsonValue) => {
+			newProps[key] = jsonValue;
+		});
+		else return unpackPropValue(value, containerResolver).then((jsonValue) => {
+			newProps[key] = jsonValue;
+		});
+	}));
+	return {
+		props: newProps,
+		mergeProps,
+		deepMergeProps,
+		deferredProps
+	};
+}
+async function buildPartialRequestProps(pageProps, cherryPickProps, containerResolver) {
+	const mergeProps = [];
+	const deepMergeProps = [];
+	const newProps = {};
+	const unpackedValues = [];
+	for (const [key, value] of Object.entries(pageProps)) if (isObject(value)) {
+		if (isAlwaysProp(value)) {
+			unpackedValues.push({
+				key,
+				value: value.value
+			});
+			continue;
+		}
+		if (!cherryPickProps.includes(key)) continue;
+		if (isDeferredProp(value)) {
+			unpackedValues.push({
+				key,
+				value: value.compute
+			});
+			continue;
+		}
+		if (isOptionalProp(value)) {
+			unpackedValues.push({
+				key,
+				value: value.compute
+			});
+			continue;
+		}
+		if (isMergeableProp(value)) {
+			if (value[DEEP_MERGE]) deepMergeProps.push(key);
+			else mergeProps.push(key);
+			if (isObject(value.value) && isDeferredProp(value.value)) unpackedValues.push({
+				key,
+				value: value.value.compute
+			});
+			else unpackedValues.push({
+				key,
+				value: value.value
+			});
+			continue;
+		}
+		unpackedValues.push({
+			key,
+			value
+		});
+	} else {
+		if (!cherryPickProps.includes(key)) continue;
+		if (typeof value === "function") {
+			unpackedValues.push({
+				key,
+				value
+			});
+			continue;
+		}
+		newProps[key] = value;
+	}
+	await Promise.all(unpackedValues.map(async ({ key, value }) => {
+		if (typeof value === "function") return Promise.resolve(value()).then((r) => unpackPropValue(r, containerResolver)).then((jsonValue) => {
+			newProps[key] = jsonValue;
+		});
+		else return unpackPropValue(value, containerResolver).then((jsonValue) => {
+			newProps[key] = jsonValue;
+		});
+	}));
+	return {
+		props: newProps,
+		mergeProps,
+		deepMergeProps,
+		deferredProps: {}
+	};
+}
+var Inertia = class {
+	#sharedStateProviders;
+	#cachedRequestInfo;
+	#serverRenderer;
+	#vite;
+	#shouldClearHistory;
+	#shouldEncryptHistory;
+	#cachedVersion;
+	defer = defer;
+	always = always;
+	merge = merge;
+	optional = optional;
+	deepMerge = deepMerge;
+	constructor(ctx, config, vite, serverRenderer) {
+		this.ctx = ctx;
+		this.config = config;
+		if (debug_default.enabled) debug_default("instantiating inertia instance for request \"%s\" using config %O", ctx.request.url(), this.config);
+		this.#shouldClearHistory = false;
+		this.#vite = vite;
+		this.#serverRenderer = serverRenderer;
+		this.#shouldEncryptHistory = config.encryptHistory ?? false;
+		this.#cachedVersion = this.config.assetsVersion ? String(this.config.assetsVersion) : void 0;
+	}
+	#resolveRootView() {
+		return typeof this.config.rootView === "function" ? this.config.rootView(this.ctx) : this.config.rootView;
+	}
+	async #buildPageProps(component, requestInfo, pageProps) {
+		let finalProps;
+		if (this.#sharedStateProviders) finalProps = {
+			...await Promise.all(this.#sharedStateProviders.map((provider) => {
+				return typeof provider === "function" ? provider() : provider;
+			})).then((resolvedSharedState) => {
+				return resolvedSharedState.reduce((result, state) => {
+					return {
+						...result,
+						...state
+					};
+				}, {});
+			}),
+			...pageProps
+		};
+		else finalProps = { ...pageProps };
+		if (requestInfo.partialComponent === component) {
+			const only = requestInfo.onlyProps;
+			const except = requestInfo.exceptProps ?? [];
+			const cherryPickProps = Object.keys(finalProps).filter((propName) => {
+				if (only) return only.includes(propName) && !except.includes(propName);
+				return !except.includes(propName);
+			});
+			debug_default("building props for a partial reload %O", requestInfo);
+			debug_default("cherry picking props %s", cherryPickProps);
+			return buildPartialRequestProps(finalProps, cherryPickProps, this.ctx.containerResolver);
+		}
+		debug_default("building props for a standard visit %O", requestInfo);
+		return buildStandardVisitProps(finalProps, this.ctx.containerResolver);
+	}
+	#handleInertiaRequest(pageObject) {
+		this.ctx.response.header(InertiaHeaders.Inertia, "true");
+		return pageObject;
+	}
+	async #renderWithSSR(pageObject, viewProps) {
+		if (!this.#serverRenderer) throw new Error("Cannot server render pages without a server renderer");
+		debug_default("server-side rendering %O", pageObject);
+		const { head, body } = await this.#serverRenderer.render(pageObject);
+		return this.ctx.view.render(this.#resolveRootView(), {
+			page: {
+				ssrHead: head,
+				ssrBody: body,
+				...pageObject
+			},
+			...viewProps
+		});
+	}
+	async #renderClientSide(pageObject, viewProps) {
+		debug_default("rendering shell for SPA %O", pageObject);
+		return this.ctx.view.render(this.#resolveRootView(), {
+			page: pageObject,
+			...viewProps
+		});
+	}
+	requestInfo(reCompute) {
+		if (reCompute) this.#cachedRequestInfo = void 0;
+		this.#cachedRequestInfo = this.#cachedRequestInfo ?? {
+			version: this.ctx.request.header(InertiaHeaders.Version),
+			isInertiaRequest: !!this.ctx.request.header(InertiaHeaders.Inertia),
+			isPartialRequest: !!this.ctx.request.header(InertiaHeaders.PartialComponent),
+			partialComponent: this.ctx.request.header(InertiaHeaders.PartialComponent),
+			onlyProps: this.ctx.request.header(InertiaHeaders.PartialOnly)?.split(","),
+			exceptProps: this.ctx.request.header(InertiaHeaders.PartialExcept)?.split(","),
+			resetProps: this.ctx.request.header(InertiaHeaders.Reset)?.split(","),
+			errorBag: this.ctx.request.header(InertiaHeaders.ErrorBag)
+		};
+		return this.#cachedRequestInfo;
+	}
+	getVersion() {
+		if (this.#cachedVersion) return this.#cachedVersion;
+		if (this.#vite?.hasManifestFile) this.#cachedVersion = createHash("md5").update(JSON.stringify(this.#vite.manifest())).digest("hex");
+		else this.#cachedVersion = "1";
+		return this.#cachedVersion;
+	}
+	async ssrEnabled(component) {
+		if (!this.config.ssr.enabled) return false;
+		if (typeof this.config.ssr.pages === "function") return this.config.ssr.pages(this.ctx, component);
+		if (this.config.ssr.pages) return this.config.ssr.pages?.includes(component);
+		return true;
+	}
+	share(sharedState) {
+		if (!this.#sharedStateProviders) this.#sharedStateProviders = [];
+		this.#sharedStateProviders.push(sharedState);
+		return this;
+	}
+	async page(page, pageProps) {
+		const requestInfo = this.requestInfo();
+		const { props, mergeProps, deferredProps, deepMergeProps } = await this.#buildPageProps(page, requestInfo, pageProps);
+		return {
+			component: page,
+			url: this.ctx.request.url(true),
+			version: this.getVersion(),
+			clearHistory: this.#shouldClearHistory,
+			encryptHistory: this.#shouldEncryptHistory,
+			props,
+			deferredProps,
+			mergeProps,
+			deepMergeProps
+		};
+	}
+	async render(page, pageProps, viewProps) {
+		const requestInfo = this.requestInfo();
+		const pageObject = await this.page(page, pageProps);
+		if (requestInfo.isInertiaRequest) return this.#handleInertiaRequest(pageObject);
+		if (await this.ssrEnabled(page)) return this.#renderWithSSR(pageObject, viewProps);
+		return this.#renderClientSide(pageObject, viewProps);
+	}
+	clearHistory() {
+		this.#shouldClearHistory = true;
+	}
+	encryptHistory(encrypt = true) {
+		this.#shouldEncryptHistory = encrypt;
+	}
+	location(url) {
+		this.ctx.response.header(InertiaHeaders.Location, url);
+		this.ctx.response.status(409);
+	}
+};
+var ServerRenderer = class {
+	#runtime;
+	#config;
+	#vite;
+	constructor(config, vite) {
+		this.#config = config;
+		this.#vite = vite;
+	}
+	async render(pageObject) {
+		let render;
+		if (this.#vite.getDevServer()) {
+			debug_default("creating SSR bundle using dev-server");
+			this.#runtime ??= await this.#vite.createModuleRunner();
+			this.#runtime.clearCache();
+			render = await this.#runtime.import(this.#config.ssr.entrypoint);
+		} else {
+			debug_default("creating SSR bundle using production build");
+			render = await import(pathToFileURL(this.#config.ssr.bundle).href);
+		}
+		const result = await render.default(pageObject);
+		debug_default("SSR bundle %o", result);
+		return {
+			head: result.head,
+			body: result.body
+		};
+	}
+};
+var InertiaManager = class {
+	#vite;
+	#config;
+	#serverRenderer;
+	constructor(config, vite) {
+		this.#config = config;
+		this.#vite = vite;
+		this.#serverRenderer = this.#vite ? new ServerRenderer(this.#config, this.#vite) : void 0;
+	}
+	createForRequest(ctx) {
+		return new Inertia(ctx, this.#config, this.#vite, this.#serverRenderer);
+	}
+};
+export { symbols_exports as i, ServerRenderer as n, Inertia as r, InertiaManager as t };

package/build/providers/inertia_provider.d.ts

@@ -1,6 +1,6 @@
 import { type Route } from '@adonisjs/core/http';
 import type { ApplicationService } from '@adonisjs/core/types';
-import type { AsPageProps, InertiaPages } from '../src/types.js';
+import type { AsPageProps, ComponentProps, InertiaPages, SharedProps } from '../src/types.js';
 declare module '@adonisjs/core/http' {
     interface BriskRoute {
         /**
@@ -29,7 +29,7 @@ declare module '@adonisjs/core/http' {
          * })
          * ```
          */
-        renderInertia<Page extends keyof InertiaPages>(component: Page, props: AsPageProps<InertiaPages[Page]>, viewProps?: Record<string, any>): Route;
+        renderInertia<Page extends keyof InertiaPages>(component: Page, props: InertiaPages[Page] extends ComponentProps ? AsPageProps<Omit<InertiaPages[Page], keyof SharedProps>> : never, viewProps?: Record<string, any>): Route;
     }
 }
 /**

package/build/providers/inertia_provider.js

@@ -1,82 +1,28 @@
-import {
-  InertiaManager
-} from "../chunk-74S2VAL7.js";
-import "../chunk-DISC5OYC.js";
-import "../chunk-4EZ2J6OA.js";
-import "../chunk-MLKGABMK.js";
-
-// providers/inertia_provider.ts
+import { t as InertiaManager } from "../inertia_manager-Di3J3hSG.js";
+import "../headers-DafWEpBh.js";
+import "../debug-CBMTuPUm.js";
 import { BriskRoute } from "@adonisjs/core/http";
 var InertiaProvider = class {
-  /**
-   * Creates a new InertiaProvider instance
-   *
-   * @param app - The AdonisJS application service instance
-   */
-  constructor(app) {
-    this.app = app;
-  }
-  /**
-   * Registers the Inertia Edge.js plugin when Edge.js is available
-   *
-   * This method conditionally registers the Edge plugin that provides
-   * @inertia and @inertiaHead tags for rendering Inertia pages.
-   *
-   * @example
-   * ```edge
-   * {{-- Templates can then use --}}
-   * @inertia(page)
-   * @inertiaHead(page)
-   * ```
-   */
-  async registerEdgePlugin() {
-    const edgeExports = await import("edge.js");
-    const { edgePluginInertia } = await import("../src/plugins/edge/plugin.js");
-    edgeExports.default.use(edgePluginInertia());
-  }
-  /**
-   * Registers the InertiaManager as a singleton in the IoC container
-   *
-   * This method sets up the core Inertia manager with the application's
-   * configuration and Vite integration. The manager handles page rendering,
-   * asset management, and SSR functionality.
-   *
-   * @example
-   * ```js
-   * // The manager is automatically available for injection:
-   * const inertiaManager = await app.container.make(InertiaManager)
-   * ```
-   */
-  async register() {
-    this.app.container.singleton(InertiaManager, async (resolver) => {
-      const config = this.app.config.get("inertia", {});
-      const vite = await resolver.make("vite");
-      return new InertiaManager(config, vite);
-    });
-  }
-  /**
-   * Boot the provider by registering Edge plugin and route macros
-   *
-   * This method completes the Inertia setup by registering the Edge plugin
-   * and adding the renderInertia macro to BriskRoute for convenient route definitions.
-   *
-   * @example
-   * ```js
-   * // Routes can now use the renderInertia macro
-   * router.get('/dashboard', []).renderInertia('Dashboard', {
-   *   user: getCurrentUser()
-   * })
-   * ```
-   */
-  async boot() {
-    await this.registerEdgePlugin();
-    BriskRoute.macro("renderInertia", function(template, props, viewProps) {
-      return this.setHandler(({ inertia }) => {
-        return inertia.render(template, props, viewProps);
-      });
-    });
-  }
-};
-export {
-  InertiaProvider as default
+	constructor(app) {
+		this.app = app;
+	}
+	async registerEdgePlugin() {
+		const edgeExports = await import("edge.js");
+		const { edgePluginInertia } = await import("../src/plugins/edge/plugin.js");
+		edgeExports.default.use(edgePluginInertia());
+	}
+	async register() {
+		this.app.container.singleton(InertiaManager, async (resolver) => {
+			return new InertiaManager(this.app.config.get("inertia", {}), await resolver.make("vite"));
+		});
+	}
+	async boot() {
+		await this.registerEdgePlugin();
+		BriskRoute.macro("renderInertia", function(template, props, viewProps) {
+			return this.setHandler(({ inertia }) => {
+				return inertia.render(template, props, viewProps);
+			});
+		});
+	}
 };
+export { InertiaProvider as default };

package/build/src/client/helpers.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Resolves a page component from a given path or array of paths by looking up
+ * the component in the provided pages registry. Supports both direct promises
+ * and lazy-loaded functions that return promises.
+ *
+ * @param path - The page path(s) to resolve. Can be a single string or array of strings
+ * @param pages - Registry of page components where keys are paths and values are either promises or functions returning promises
+ * @param layout - Optional layout component to assign to the resolved page
+ * @returns Promise resolving to the page component
+ *
+ * @example
+ * ```js
+ * // Single path resolution
+ * const component = await resolvePageComponent('Home', {
+ *   'Home': () => import('./pages/Home.vue'),
+ *   'About': () => import('./pages/About.vue')
+ * })
+ *
+ * // Multiple path resolution (fallback)
+ * const component = await resolvePageComponent(['Dashboard/Admin', 'Dashboard'], {
+ *   'Dashboard': () => import('./pages/Dashboard.vue')
+ * })
+ * ```
+ *
+ * @throws Error When none of the provided paths can be resolved in the pages registry
+ */
+export declare function resolvePageComponent<T>(path: string | string[], pages: Record<string, Promise<T> | (() => Promise<T>) | T>, layout?: any): Promise<T>;

package/build/src/client/helpers.js

@@ -0,0 +1,13 @@
+async function resolvePageComponent(path, pages, layout) {
+	for (const p of Array.isArray(path) ? path : [path]) {
+		const page = pages[p];
+		if (typeof page === "undefined") continue;
+		const resolvedPage = await (typeof page === "function" ? page() : page);
+		if (!resolvedPage) throw new Error(`Invalid page exported from "${path}". Make sure to default export a function`);
+		if ("default" in resolvedPage === false) throw new Error(`Invalid page exported from "${path}". Make sure to default export a function`);
+		if (layout && !resolvedPage.default.layout) resolvedPage.default.layout = layout;
+		return resolvedPage;
+	}
+	throw new Error(`Page not found: "${path}"`);
+}
+export { resolvePageComponent };

package/build/src/client/react/context.d.ts

@@ -0,0 +1,24 @@
+import React from 'react';
+import type { Tuyau } from '@tuyau/core/client';
+import type { AdonisRegistry } from '@tuyau/core/types';
+/**
+ * Provider component that makes the Tuyau client available to child components.
+ *
+ * This component should wrap your entire application or the part of your
+ * application that needs access to type-safe routing functionality.
+ *
+ */
+export declare function TuyauProvider<R extends AdonisRegistry>(props: {
+    children: React.ReactNode;
+    client: Tuyau<R>;
+}): React.JSX.Element;
+/**
+ * Hook to access the Tuyau client from any component within a TuyauProvider.
+ *
+ * Provides type-safe access to route generation and navigation utilities.
+ * Must be used within a component tree wrapped by TuyauProvider.
+ *
+ * @returns The Tuyau client instance with full type safety
+ * @throws Error if used outside of a TuyauProvider
+ */
+export declare function useTuyau(): Tuyau<any>;

package/build/src/client/react/index.d.ts

@@ -0,0 +1,3 @@
+export * from './context.tsx';
+export * from './router.ts';
+export * from './link.tsx';

package/build/src/client/react/index.js

@@ -0,0 +1,29 @@
+import React from "react";
+import { Link as Link$1, router } from "@inertiajs/react";
+const TuyauContext = React.createContext(null);
+function TuyauProvider(props) {
+	return <TuyauContext.Provider value={props.client}>{props.children}</TuyauContext.Provider>;
+}
+function useTuyau() {
+	const context = React.useContext(TuyauContext);
+	if (!context) throw new Error("You must wrap your app in a TuyauProvider");
+	return context;
+}
+function useRouter() {
+	const tuyau = useTuyau();
+	return { visit: (props, options) => {
+		const routeInfo = tuyau.getRoute(props.route, { params: props.params });
+		const url = routeInfo.url;
+		return router.visit(url, {
+			...options,
+			method: routeInfo.methods[0].toLowerCase()
+		});
+	} };
+}
+function LinkInner(props, ref) {
+	const { route, params, ...linkProps } = props;
+	const routeInfo = useTuyau().getRoute(props.route, { params });
+	return <Link$1 {...linkProps} href={routeInfo.url} method={routeInfo.methods[0].toLowerCase()} ref={ref} />;
+}
+const Link = React.forwardRef(LinkInner);
+export { Link, TuyauProvider, useRouter, useTuyau };

package/build/src/client/react/link.d.ts

@@ -0,0 +1,64 @@
+import React from 'react';
+import type { UserRegistry } from '@tuyau/core/types';
+import { AreAllOptional } from '@poppinss/utils/types';
+import { Link as InertiaLink } from '@inertiajs/react';
+/**
+ * Get parameter tuple type for a route
+ */
+type ExtractParamsTuple<Route extends keyof UserRegistry> = UserRegistry[Route]['types']['paramsTuple'];
+/**
+ * Get parameter object type for a route
+ */
+type ExtractParamsObject<Route extends keyof UserRegistry> = UserRegistry[Route]['types']['params'];
+/**
+ * Get params format for a route
+ */
+type RouteParamsFormats<Route extends keyof UserRegistry> = ExtractParamsObject<Route> extends Record<string, never> ? never : ExtractParamsTuple<Route> | ExtractParamsObject<Route>;
+/**
+ * Parameters required for route navigation with proper type safety.
+ */
+export type LinkParams<Route extends keyof UserRegistry> = {
+    route: Route;
+} & (RouteParamsFormats<Route> extends never ? {
+    params?: never;
+} : AreAllOptional<ExtractParamsObject<Route>> extends true ? {
+    params?: RouteParamsFormats<Route>;
+} : {
+    params: RouteParamsFormats<Route>;
+});
+/**
+ * Props for the Link component extending InertiaLink props
+ * with route-specific type safety and parameter validation.
+ */
+type LinkProps<Route extends keyof UserRegistry> = Omit<React.ComponentPropsWithoutRef<typeof InertiaLink>, 'href' | 'method'> & LinkParams<Route>;
+/**
+ * Internal Link component implementation with forward ref support.
+ * Resolves route parameters and generates the appropriate URL and HTTP method
+ * for Inertia navigation.
+ *
+ * @param props - Link properties including route and parameters
+ * @param ref - Forward ref for the underlying InertiaLink component
+ */
+declare function LinkInner<Route extends keyof UserRegistry>(props: LinkProps<Route>, ref?: React.ForwardedRef<React.ElementRef<typeof InertiaLink>>): React.JSX.Element;
+/**
+ * Type-safe Link component for Inertia.js navigation.
+ *
+ * Provides compile-time route validation and automatic parameter type checking
+ * based on your application's route definitions. Automatically resolves the
+ * correct URL and HTTP method for each route.
+ *
+ * @example
+ * ```tsx
+ * // Link to a route without parameters
+ * <Link route="home">Home</Link>
+ *
+ * // Link to a route with required parameters
+ * <Link route="user.show" params={{ id: 1 }}>
+ *   View User
+ * </Link>
+ * ```
+ */
+export declare const Link: <Route extends keyof UserRegistry>(props: LinkProps<Route> & {
+    ref?: React.Ref<React.ElementRef<typeof InertiaLink>>;
+}) => ReturnType<typeof LinkInner>;
+export {};