@adonisjs/inertia 4.0.0-next.9 → 4.1.0

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

@@ -0,0 +1,62 @@
+import React from "react";
+import { jsx } from "react/jsx-runtime";
+import { Form as Form$1, Link as Link$1, router } from "@inertiajs/react";
+const TuyauContext = React.createContext(null);
+function TuyauProvider(props) {
+	return /* @__PURE__ */ jsx(TuyauContext.Provider, {
+		value: props.client,
+		children: props.children
+	});
+}
+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) => {
+		if ("href" in props) return router.visit(props.href, options);
+		const routeInfo = tuyau.getRoute(props.route, { params: props.routeParams });
+		const url = routeInfo.url;
+		return router.visit(url, {
+			...options,
+			method: routeInfo.methods[0].toLowerCase()
+		});
+	} };
+}
+function LinkInner(props, ref) {
+	const tuyau = useTuyau();
+	if ("href" in props) return /* @__PURE__ */ jsx(Link$1, {
+		...props,
+		ref
+	});
+	const { route: _route, routeParams: params, ...linkProps } = props;
+	const routeInfo = tuyau.getRoute(props.route, { params });
+	return /* @__PURE__ */ jsx(Link$1, {
+		...linkProps,
+		href: routeInfo.url,
+		method: routeInfo.methods[0].toLowerCase(),
+		ref
+	});
+}
+const Link = React.forwardRef(LinkInner);
+function FormInner(props, ref) {
+	const tuyau = useTuyau();
+	if ("action" in props) return /* @__PURE__ */ jsx(Form$1, {
+		...props,
+		ref
+	});
+	const { route: _route, routeParams: params, ...formProps } = props;
+	const routeInfo = tuyau.getRoute(props.route, { params });
+	return /* @__PURE__ */ jsx(Form$1, {
+		...formProps,
+		action: {
+			url: routeInfo.url,
+			method: routeInfo.methods[0].toLowerCase()
+		},
+		ref
+	});
+}
+const Form = React.forwardRef(FormInner);
+export { Form, Link, TuyauProvider, useRouter, useTuyau };

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

@@ -0,0 +1,59 @@
+import React from 'react';
+import { Link as InertiaLink } from '@inertiajs/react';
+import type { RouteParams, Routes } from '../common.ts';
+/**
+ * Parameters required for route navigation with proper type safety.
+ */
+export type LinkParams<Route extends keyof Routes> = RouteParams<Route>;
+/**
+ * Props for the Link component when using route-based navigation
+ */
+export type LinkRouteProps<Route extends keyof Routes> = Omit<React.ComponentPropsWithoutRef<typeof InertiaLink>, 'href' | 'method'> & LinkParams<Route> & {
+    href?: never;
+};
+/**
+ * Props for the Link component when using direct href
+ */
+export type LinkHrefProps = Omit<React.ComponentPropsWithoutRef<typeof InertiaLink>, 'route'> & {
+    route?: never;
+};
+/**
+ * Union type for Link component props - either route-based or direct href
+ */
+export type LinkProps<Route extends keyof Routes = keyof Routes> = LinkRouteProps<Route> | LinkHrefProps;
+/**
+ * Internal Link component implementation with forward ref support.
+ * Resolves route parameters and generates the appropriate URL and HTTP method
+ * for Inertia navigation when using route-based navigation.
+ * Falls back to standard InertiaLink when href is provided directly.
+ *
+ * @param props - Link properties including route and parameters, or direct href
+ * @param ref - Forward ref for the underlying InertiaLink component
+ */
+declare function LinkInner<Route extends keyof Routes>(props: LinkProps<Route>, ref?: React.ForwardedRef<React.ElementRef<typeof InertiaLink>>): import("react/jsx-runtime").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. Alternatively, you can use
+ * the standard href prop for direct navigation.
+ *
+ * @example
+ * ```tsx
+ * // Link to a route without parameters
+ * <Link route="home">Home</Link>
+ *
+ * // Link to a route with required parameters
+ * <Link route="user.show" routeParams={{ id: 1 }}>
+ *   View User
+ * </Link>
+ *
+ * // Link with direct href
+ * <Link href="/about">About</Link>
+ * ```
+ */
+export declare const Link: <Route extends keyof Routes>(props: LinkProps<Route> & {
+    ref?: React.Ref<React.ElementRef<typeof InertiaLink>>;
+}) => ReturnType<typeof LinkInner>;
+export {};

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

@@ -0,0 +1,60 @@
+import type { UserRegistry, InferRoutes } from '@tuyau/core/types';
+import { router as InertiaRouter } from '@inertiajs/react';
+import type { LinkParams } from './link.tsx';
+/**
+ * Parameters for route-based visit
+ */
+type VisitRouteParams<Route extends keyof InferRoutes<UserRegistry>> = LinkParams<Route> & {
+    href?: never;
+};
+/**
+ * Parameters for direct href visit - supports all Inertia visit parameters
+ */
+type VisitHrefParams = {
+    href: Parameters<typeof InertiaRouter.visit>[0];
+    route?: never;
+};
+/**
+ * Union type for visit parameters - either route-based or direct href
+ */
+type VisitParams<Route extends keyof InferRoutes<UserRegistry> = keyof InferRoutes<UserRegistry>> = VisitRouteParams<Route> | VisitHrefParams;
+/**
+ * Custom hook providing type-safe navigation utilities for Inertia.js.
+ *
+ * Returns an enhanced router object with type-safe navigation methods
+ * that automatically resolve route URLs and HTTP methods based on
+ * your application's route definitions. Alternatively, you can use
+ * direct href for navigation.
+ *
+ * @returns Router object with type-safe navigation methods
+ */
+export declare function useRouter(): {
+    /**
+     * Navigate to a route with type-safe parameters and options, or use
+     * direct href for navigation.
+     *
+     * When using route-based navigation, automatically resolves the route
+     * URL and HTTP method based on the route definition. When using direct
+     * href, passes through to Inertia's router.
+     *
+     * @param props - Route navigation parameters or direct href
+     * @param options - Optional Inertia visit options for controlling navigation behavior
+     *
+     * @example
+     * ```tsx
+     * // Navigate to a simple route
+     * router.visit({ route: 'dashboard' })
+     *
+     * // Navigate with parameters
+     * router.visit({ route: 'user.edit', routeParams: { id: userId } })
+     *
+     * // Navigate with direct href
+     * router.visit({ href: '/about' })
+     *
+     * // Navigate with direct href and method
+     * router.visit({ href: '/logout' }, { method: 'post' })
+     * ```
+     */
+    visit: <Route extends keyof InferRoutes<UserRegistry>>(props: VisitParams<Route>, options?: Parameters<typeof InertiaRouter.visit>[1]) => any;
+};
+export {};

package/build/src/client/vite.js

@@ -1,31 +1,21 @@
-import "../../chunk-MLKGABMK.js";
-
-// src/client/vite.ts
 function inertia(options) {
-  return {
-    name: "vite-plugin-inertia",
-    config: (_, { command }) => {
-      if (command === "build") {
-        process.env.NODE_ENV = "production";
-      }
-      return {
-        builder: {},
-        build: { outDir: "build/public/assets" },
-        environments: {
-          ...options?.ssr?.enabled && {
-            ssr: {
-              build: {
-                ssr: true,
-                outDir: options.ssr.output || "build/ssr",
-                rollupOptions: { input: options.ssr.entrypoint }
-              }
-            }
-          }
-        }
-      };
-    }
-  };
+	return {
+		name: "vite-plugin-inertia",
+		config: (_, { command }) => {
+			if (command === "build") process.env.NODE_ENV = "production";
+			return {
+				builder: { buildApp: async (builder) => {
+					await builder.build(builder.environments.client);
+					if (options?.ssr?.enabled) await builder.build(builder.environments.ssr);
+				} },
+				build: { outDir: "build/public/assets" },
+				environments: { ...options?.ssr?.enabled && { ssr: { build: {
+					ssr: true,
+					outDir: options.ssr.output || "build/ssr",
+					rollupOptions: { input: options.ssr.entrypoint }
+				} } } }
+			};
+		}
+	};
 }
-export {
-  inertia as default
-};
+export { inertia as default };

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

@@ -0,0 +1,23 @@
+import type { Tuyau } from '@tuyau/core/client';
+import type { TuyauRegistry } from '@tuyau/core/types';
+import type { PropType } from 'vue';
+/**
+ * Provider component that makes the Tuyau client available to child components.
+ */
+export declare const TuyauProvider: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    client: {
+        type: PropType<Tuyau<TuyauRegistry>>;
+        required: true;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[] | undefined, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    client: {
+        type: PropType<Tuyau<TuyauRegistry>>;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+/**
+ * Composable to access the Tuyau client from any component within a TuyauProvider.
+ */
+export declare function useTuyau(): Tuyau<any, any>;

package/build/src/client/vue/form.d.ts

@@ -0,0 +1,68 @@
+import type { PropType, SlotsType } from 'vue';
+import { Form as InertiaForm } from '@inertiajs/vue3';
+import type { RouteParams, RouteParamsFormats, Routes } from '../common.ts';
+export type InertiaFormSlots = InstanceType<typeof InertiaForm>['$slots'];
+export type InertiaFormDefaultSlot = InertiaFormSlots['default'];
+export type InertiaFormSlotProps = InertiaFormDefaultSlot extends (...args: any[]) => any ? Parameters<InertiaFormDefaultSlot>[0] : never;
+/**
+ * Parameters required for route navigation with proper type safety.
+ */
+export type FormParams<Route extends keyof Routes> = RouteParams<Route>;
+/**
+ * Type-safe Form component for Inertia.js form submissions.
+ *
+ * Supports both route-based form submission with automatic URL resolution
+ * and direct action for maximum flexibility.
+ *
+ * @example
+ * ```vue
+ * <!-- Route-based form -->
+ * <Form route="users.store" v-slot="{ processing }">
+ *   <input type="text" name="name" />
+ *   <button :disabled="processing">Create</button>
+ * </Form>
+ *
+ * <!-- Direct action form -->
+ * <Form :action="{ url: '/users', method: 'post' }" v-slot="{ processing }">
+ *   <input type="text" name="name" />
+ *   <button :disabled="processing">Create</button>
+ * </Form>
+ * ```
+ */
+export declare const Form: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    route: {
+        type: PropType<keyof Routes>;
+        required: false;
+    };
+    params: {
+        type: PropType<RouteParamsFormats<keyof Routes>>;
+        required: false;
+    };
+    action: {
+        type: PropType<{
+            url: string;
+            method: string;
+        }>;
+        required: false;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    route: {
+        type: PropType<keyof Routes>;
+        required: false;
+    };
+    params: {
+        type: PropType<RouteParamsFormats<keyof Routes>>;
+        required: false;
+    };
+    action: {
+        type: PropType<{
+            url: string;
+            method: string;
+        }>;
+        required: false;
+    };
+}>> & Readonly<{}>, {}, SlotsType<{
+    default: InertiaFormSlotProps;
+}>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

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

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

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

@@ -0,0 +1,103 @@
+import { defineComponent, h, inject, provide } from "vue";
+import { Form as Form$1, Link as Link$1, router } from "@inertiajs/vue3";
+const TuyauContext = Symbol("Tuyau");
+const TuyauProvider = defineComponent({
+	name: "TuyauProvider",
+	props: { client: {
+		type: Object,
+		required: true
+	} },
+	setup(props, { slots }) {
+		provide(TuyauContext, props.client);
+		return () => slots.default?.();
+	}
+});
+function useTuyau() {
+	const context = inject(TuyauContext, null);
+	if (!context) throw new Error("You must wrap your app in a TuyauProvider");
+	return context;
+}
+function useRouter() {
+	const tuyau = useTuyau();
+	return { visit: (props, options) => {
+		if ("href" in props) return router.visit(props.href, options);
+		const routeInfo = tuyau.getRoute(props.route, { params: props.routeParams });
+		const url = routeInfo.url;
+		return router.visit(url, {
+			...options,
+			method: routeInfo.methods[0].toLowerCase()
+		});
+	} };
+}
+const Link = defineComponent({
+	name: "TuyauLink",
+	inheritAttrs: false,
+	props: {
+		route: {
+			type: String,
+			required: false
+		},
+		params: {
+			type: [Array, Object],
+			required: false
+		},
+		href: {
+			type: String,
+			required: false
+		}
+	},
+	setup(props, { attrs, slots }) {
+		const tuyau = useTuyau();
+		return () => {
+			if (props.href) return h(Link$1, {
+				...attrs,
+				href: props.href
+			}, slots);
+			if (!props.route) throw new Error("Either route or href prop is required for Link component");
+			const routeInfo = tuyau.getRoute(props.route, { params: props.params });
+			return h(Link$1, {
+				...attrs,
+				href: routeInfo.url,
+				method: routeInfo.methods[0].toLowerCase()
+			}, slots);
+		};
+	}
+});
+const Form = defineComponent({
+	name: "TuyauForm",
+	inheritAttrs: false,
+	slots: Object,
+	props: {
+		route: {
+			type: String,
+			required: false
+		},
+		params: {
+			type: [Array, Object],
+			required: false
+		},
+		action: {
+			type: Object,
+			required: false
+		}
+	},
+	setup(props, { attrs, slots }) {
+		const tuyau = useTuyau();
+		return () => {
+			if (props.action) return h(Form$1, {
+				...attrs,
+				action: props.action
+			}, slots);
+			if (!props.route) throw new Error("Either route or action prop is required for Form component");
+			const routeInfo = tuyau.getRoute(props.route, { params: props.params });
+			return h(Form$1, {
+				...attrs,
+				action: {
+					url: routeInfo.url,
+					method: routeInfo.methods[0].toLowerCase()
+				}
+			}, slots);
+		};
+	}
+});
+export { Form, Link, TuyauProvider, useRouter, useTuyau };

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

@@ -0,0 +1,52 @@
+import type { PropType } from 'vue';
+import type { RouteParams, RouteParamsFormats, Routes } from '../common.ts';
+/**
+ * Parameters required for route navigation with proper type safety.
+ */
+export type LinkParams<Route extends keyof Routes> = RouteParams<Route>;
+/**
+ * Type-safe Link component for Inertia.js navigation.
+ *
+ * Supports both route-based navigation with automatic URL resolution
+ * and direct href navigation for maximum flexibility.
+ *
+ * @example
+ * ```vue
+ * <!-- Route-based navigation -->
+ * <Link route="users.index">Users</Link>
+ * <Link route="users.show" :params="{ id: 1 }">View User</Link>
+ *
+ * <!-- Direct href navigation -->
+ * <Link href="/about">About</Link>
+ * <Link href="/logout" method="post">Logout</Link>
+ * ```
+ */
+export declare const Link: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    route: {
+        type: PropType<keyof Routes>;
+        required: false;
+    };
+    params: {
+        type: PropType<RouteParamsFormats<keyof Routes>>;
+        required: false;
+    };
+    href: {
+        type: StringConstructor;
+        required: false;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    route: {
+        type: PropType<keyof Routes>;
+        required: false;
+    };
+    params: {
+        type: PropType<RouteParamsFormats<keyof Routes>>;
+        required: false;
+    };
+    href: {
+        type: StringConstructor;
+        required: false;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/build/src/client/vue/router.d.ts

@@ -0,0 +1,62 @@
+import { router as InertiaRouter } from '@inertiajs/vue3';
+import type { UserRegistry, InferRoutes } from '@tuyau/core/types';
+import type { LinkParams } from './link.ts';
+/**
+ * Parameters for route-based visit
+ */
+type VisitRouteParams<Route extends keyof InferRoutes<UserRegistry>> = LinkParams<Route> & {
+    href?: never;
+};
+/**
+ * Parameters for direct href visit - supports all Inertia visit parameters
+ */
+type VisitHrefParams = {
+    href: Parameters<typeof InertiaRouter.visit>[0];
+    route?: never;
+};
+/**
+ * Union type for visit parameters - either route-based or direct href
+ */
+type VisitParams<Route extends keyof InferRoutes<UserRegistry> = keyof InferRoutes<UserRegistry>> = VisitRouteParams<Route> | VisitHrefParams;
+/**
+ * Composable providing type-safe navigation utilities for Inertia.js.
+ *
+ * Returns an enhanced router object with type-safe navigation methods
+ * that automatically resolve route URLs and HTTP methods based on
+ * your application's route definitions. Alternatively, you can use
+ * direct href for navigation.
+ *
+ * @returns Router object with type-safe navigation methods
+ */
+export declare function useRouter(): {
+    /**
+     * Navigate to a route with type-safe parameters and options, or use
+     * direct href for navigation.
+     *
+     * When using route-based navigation, automatically resolves the route
+     * URL and HTTP method based on the route definition. When using direct
+     * href, passes through to Inertia's router.
+     *
+     * @param props - Route navigation parameters or direct href
+     * @param options - Optional Inertia visit options for controlling navigation behavior
+     *
+     * @example
+     * ```ts
+     * const router = useRouter()
+     *
+     * // Navigate to a simple route
+     * router.visit({ route: 'dashboard' })
+     *
+     * // Navigate with parameters
+     * router.visit({ route: 'user.edit', params: { id: userId } })
+     *
+     * // Navigate with direct href
+     * router.visit({ href: '/about' })
+     *
+     * // Navigate with direct href and method
+     * router.visit({ href: '/logout' }, { method: 'post' })
+     * ```
+     */
+    visit: <Route extends keyof InferRoutes<UserRegistry>>(props: VisitParams<Route>, options?: Parameters<typeof InertiaRouter.visit>[1]) => any;
+};
+export {};

package/build/src/debug.d.ts

@@ -18,5 +18,5 @@
  * NODE_DEBUG=adonisjs:inertia node server.js
  * ```
  */
-declare const _default: import("util").DebugLogger;
+declare const _default: import("node:util").DebugLogger;
 export default _default;

package/build/src/index_pages.d.ts

@@ -7,6 +7,7 @@
  *
  * @param config - Configuration object specifying the frontend framework
  * @param config.framework - The frontend framework ('vue3' or 'react')
+ * @param config.source - The path to Inertia pages (default: inertia/pages)
  * @returns Assembler hook object with run method for generating page types
  *
  * @example
@@ -21,12 +22,42 @@
  */
 export declare const indexPages: (config: {
     framework: "vue3" | "react";
+    source?: string;
 }) => {
     /**
      * Executes the page indexing process to generate TypeScript definitions.
      *
      * @param _ - Unused first parameter (assembler context)
+     * @param __ - Unused second parameter (hooks instance)
      * @param indexGenerator - The index generator instance used to register the pages type generation
      */
-    run(_: import("@adonisjs/assembler").DevServer | import("@adonisjs/assembler").TestRunner | import("@adonisjs/assembler").Bundler, indexGenerator: import("@adonisjs/assembler/index_generator").IndexGenerator): void;
+    run(_: import("@adonisjs/assembler").DevServer | import("@adonisjs/assembler").TestRunner | import("@adonisjs/assembler").Bundler, __: import("@poppinss/hooks").default<{
+        init: [[parent: import("@adonisjs/assembler").DevServer | import("@adonisjs/assembler").TestRunner | import("@adonisjs/assembler").Bundler, hooks: import("@poppinss/hooks").default</*elided*/ any>, indexGenerator: import("@adonisjs/assembler/index_generator").IndexGenerator], [parent: import("@adonisjs/assembler").DevServer | import("@adonisjs/assembler").TestRunner | import("@adonisjs/assembler").Bundler, hooks: import("@poppinss/hooks").default</*elided*/ any>, indexGenerator: import("@adonisjs/assembler/index_generator").IndexGenerator]];
+        fileChanged: [[relativePath: string, absolutePath: string, info: {
+            source: "hot-hook" | "watcher";
+            hotReloaded: boolean;
+            fullReload: boolean;
+        }, parent: import("@adonisjs/assembler").DevServer | import("@adonisjs/assembler").TestRunner], [relativePath: string, absolutePath: string, info: {
+            source: "hot-hook" | "watcher";
+            hotReloaded: boolean;
+            fullReload: boolean;
+        }, parent: import("@adonisjs/assembler").DevServer | import("@adonisjs/assembler").TestRunner]];
+        fileAdded: [[relativePath: string, absolutePath: string, server: import("@adonisjs/assembler").DevServer | import("@adonisjs/assembler").TestRunner], [relativePath: string, absolutePath: string, server: import("@adonisjs/assembler").DevServer | import("@adonisjs/assembler").TestRunner]];
+        fileRemoved: [[relativePath: string, absolutePath: string, server: import("@adonisjs/assembler").DevServer | import("@adonisjs/assembler").TestRunner], [relativePath: string, absolutePath: string, server: import("@adonisjs/assembler").DevServer | import("@adonisjs/assembler").TestRunner]];
+        devServerStarting: [[server: import("@adonisjs/assembler").DevServer], [server: import("@adonisjs/assembler").DevServer]];
+        devServerStarted: [[server: import("@adonisjs/assembler").DevServer, info: {
+            port: number;
+            host: string;
+        }, uiInstructions: import("@poppinss/cliui").Instructions], [server: import("@adonisjs/assembler").DevServer, info: {
+            port: number;
+            host: string;
+        }, uiInstructions: import("@poppinss/cliui").Instructions]];
+        buildStarting: [[server: import("@adonisjs/assembler").Bundler], [server: import("@adonisjs/assembler").Bundler]];
+        buildFinished: [[server: import("@adonisjs/assembler").Bundler, uiInstructions: import("@poppinss/cliui").Instructions], [server: import("@adonisjs/assembler").Bundler, uiInstructions: import("@poppinss/cliui").Instructions]];
+        testsStarting: [[server: import("@adonisjs/assembler").TestRunner], [server: import("@adonisjs/assembler").TestRunner]];
+        testsFinished: [[server: import("@adonisjs/assembler").TestRunner], [server: import("@adonisjs/assembler").TestRunner]];
+        routesCommitted: [[parent: import("@adonisjs/assembler").DevServer, routes: Record<string, import("@adonisjs/assembler/types").RoutesListItem[]>], [parent: import("@adonisjs/assembler").DevServer, routes: Record<string, import("@adonisjs/assembler/types").RoutesListItem[]>]];
+        routesScanning: [[parent: import("@adonisjs/assembler").DevServer, routesScanner: import("@adonisjs/assembler/routes_scanner").RoutesScanner], [parent: import("@adonisjs/assembler").DevServer, routesScanner: import("@adonisjs/assembler/routes_scanner").RoutesScanner]];
+        routesScanned: [[parent: import("@adonisjs/assembler").DevServer, routesScanner: import("@adonisjs/assembler/routes_scanner").RoutesScanner], [parent: import("@adonisjs/assembler").DevServer, routesScanner: import("@adonisjs/assembler/routes_scanner").RoutesScanner]];
+    }>, indexGenerator: import("@adonisjs/assembler/index_generator").IndexGenerator): void;
 };