litestar-vite-plugin 0.15.0-alpha.2 → 0.15.0-alpha.4

package/dist/js/helpers/routes.d.ts

@@ -34,12 +34,26 @@ export interface RoutesMap {
  * Convenience alias for route names when using injected metadata.
  */
 export type RouteName = keyof RoutesMap["routes"];
+/**
+ * Litestar helpers namespace for clean global access.
+ */
+export interface LitestarHelpers {
+    route: typeof route;
+    toRoute: typeof toRoute;
+    currentRoute: typeof currentRoute;
+    isRoute: typeof isRoute;
+    isCurrentRoute: typeof isCurrentRoute;
+    getRelativeUrlPath: typeof getRelativeUrlPath;
+    routes: Record<string, string>;
+}
 declare global {
     interface Window {
         __LITESTAR_ROUTES__?: RoutesMap;
+        __LITESTAR__?: LitestarHelpers;
         routes?: Record<string, string>;
         serverRoutes?: Record<string, string>;
     }
+    var __LITESTAR__: LitestarHelpers | undefined;
     var routes: Record<string, string>;
     var serverRoutes: Record<string, string>;
 }
@@ -137,4 +151,9 @@ export declare function isRoute(url: string, routeName: string): boolean;
  * ```
  */
 export declare function isCurrentRoute(routeName: string): boolean;
+/**
+ * Litestar helpers namespace object.
+ * Access via window.__LITESTAR__ or import functions directly from this module.
+ */
+export declare const LITESTAR: LitestarHelpers;
 export {};

package/dist/js/helpers/routes.js

@@ -13,6 +13,40 @@
  *
  * @module
  */
+/**
+ * Cache for compiled route patterns to avoid repeated regex compilation.
+ */
+const routePatternCache = new Map();
+/**
+ * Compile a route pattern to a regex for URL matching.
+ * Results are cached for performance.
+ *
+ * @param routePattern - Route pattern with optional {param:type} placeholders
+ * @returns Compiled regex pattern
+ */
+function compileRoutePattern(routePattern) {
+    const cached = routePatternCache.get(routePattern);
+    if (cached) {
+        return cached;
+    }
+    const regexPattern = routePattern.replace(/\//g, "\\/").replace(/\{([^}]+)\}/g, (_, paramSpec) => {
+        // Handle {param:type} syntax
+        const paramType = paramSpec.includes(":") ? paramSpec.split(":")[1] : "str";
+        switch (paramType) {
+            case "uuid":
+                return "[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}";
+            case "path":
+                return ".*";
+            case "int":
+                return "\\d+";
+            default:
+                return "[^/]+";
+        }
+    });
+    const compiled = new RegExp(`^${regexPattern}$`);
+    routePatternCache.set(routePattern, compiled);
+    return compiled;
+}
 /**
  * Get the routes object from the page.
  *
@@ -154,21 +188,7 @@ export function toRoute(url) {
     const processedUrl = getRelativeUrlPath(url);
     const normalizedUrl = processedUrl === "/" ? processedUrl : processedUrl.replace(/\/$/, "");
     for (const [routeName, routePattern] of Object.entries(routes)) {
-        const regexPattern = routePattern.replace(/\//g, "\\/").replace(/\{([^}]+)\}/g, (_, paramSpec) => {
-            // Handle {param:type} syntax
-            const paramType = paramSpec.includes(":") ? paramSpec.split(":")[1] : "str";
-            switch (paramType) {
-                case "uuid":
-                    return "[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}";
-                case "path":
-                    return ".*";
-                case "int":
-                    return "\\d+";
-                default:
-                    return "[^/]+";
-            }
-        });
-        const regex = new RegExp(`^${regexPattern}$`);
+        const regex = compileRoutePattern(routePattern);
         if (regex.test(normalizedUrl)) {
             return routeName;
         }
@@ -214,20 +234,7 @@ export function isRoute(url, routeName) {
     const matchingRouteNames = Object.keys(routes).filter((name) => routeNameRegex.test(name));
     for (const name of matchingRouteNames) {
         const routePattern = routes[name];
-        const regexPattern = routePattern.replace(/\//g, "\\/").replace(/\{([^}]+)\}/g, (_, paramSpec) => {
-            const paramType = paramSpec.includes(":") ? paramSpec.split(":")[1] : "str";
-            switch (paramType) {
-                case "uuid":
-                    return "[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}";
-                case "path":
-                    return "(.*)";
-                case "int":
-                    return "(\\d+)";
-                default:
-                    return "([^/]+)";
-            }
-        });
-        const regex = new RegExp(`^${regexPattern}$`);
+        const regex = compileRoutePattern(routePattern);
         if (regex.test(normalizedUrl)) {
             return true;
         }
@@ -255,17 +262,27 @@ export function isCurrentRoute(routeName) {
     const routeNameRegex = new RegExp(`^${routeName.replace(/\*/g, ".*")}$`);
     return routeNameRegex.test(current);
 }
-// Set up global functions for backward compatibility
+/**
+ * Litestar helpers namespace object.
+ * Access via window.__LITESTAR__ or import functions directly from this module.
+ */
+export const LITESTAR = {
+    route,
+    toRoute,
+    currentRoute,
+    isRoute,
+    isCurrentRoute,
+    getRelativeUrlPath,
+    routes: {},
+};
+// Set up namespaced global access
 if (typeof globalThis !== "undefined") {
-    globalThis.routes = globalThis.routes || {};
+    globalThis.__LITESTAR__ = LITESTAR;
+    // Also set up routes for internal use
+    globalThis.routes = globalThis.routes || LITESTAR.routes;
     globalThis.serverRoutes = globalThis.serverRoutes || globalThis.routes;
-    globalThis.route = route;
-    globalThis.toRoute = toRoute;
-    globalThis.currentRoute = currentRoute;
-    globalThis.isRoute = isRoute;
-    globalThis.isCurrentRoute = isCurrentRoute;
 }
-// Keep serverRoutes fresh during Vite HMR when the plugin regenerates metadata/types
+// Keep routes fresh during Vite HMR when the plugin regenerates metadata/types
 if (import.meta.hot) {
     import.meta.hot.on("litestar:types-updated", () => {
         if (typeof window === "undefined") {
@@ -273,8 +290,13 @@ if (import.meta.hot) {
         }
         const updated = getRoutes();
         if (updated) {
+            // Update all references
+            LITESTAR.routes = updated;
             window.serverRoutes = updated;
             window.routes = updated;
+            if (window.__LITESTAR__) {
+                window.__LITESTAR__.routes = updated;
+            }
         }
     });
 }

package/dist/js/index.d.ts

@@ -1,4 +1,3 @@
-import { type ConfigEnv, type Plugin, type UserConfig } from "vite";
 import { type Config as FullReloadConfig } from "vite-plugin-full-reload";
 /**
  * Configuration for TypeScript type generation.
@@ -147,20 +146,28 @@ export interface PluginConfig {
      * @default false
      */
     types?: boolean | TypesConfig;
+    /**
+     * JavaScript runtime executor for package commands.
+     * Used when running tools like @hey-api/openapi-ts.
+     *
+     * This is typically auto-detected from Python config via LITESTAR_VITE_RUNTIME env var,
+     * but can be overridden here for JS-only projects or specific needs.
+     *
+     * @default undefined (uses LITESTAR_VITE_RUNTIME env or 'node')
+     */
+    executor?: "node" | "bun" | "deno" | "yarn" | "pnpm";
 }
 interface RefreshConfig {
     paths: string[];
     config?: FullReloadConfig;
 }
-interface LitestarPlugin extends Plugin {
-    config: (config: UserConfig, env: ConfigEnv) => UserConfig;
-}
 type DevServerUrl = `${"http" | "https"}://${string}:${number}`;
 export declare const refreshPaths: string[];
 /**
  * Litestar plugin for Vite.
  *
  * @param config - A config object or relative path(s) of the scripts to be compiled.
+ * @returns An array of Vite plugins. Return type is `any[]` to avoid cross-version type conflicts.
  */
-export default function litestar(config: string | string[] | PluginConfig): [LitestarPlugin, ...Plugin[]];
+export default function litestar(config: string | string[] | PluginConfig): any[];
 export {};

package/dist/js/index.js

@@ -7,8 +7,9 @@ import { promisify } from "node:util";
 import colors from "picocolors";
 import { loadEnv } from "vite";
 import fullReload from "vite-plugin-full-reload";
-import { resolveInstallHint } from "./install-hint.js";
+import { resolveInstallHint, resolvePackageExecutor } from "./install-hint.js";
 import { checkBackendAvailability, loadLitestarMeta } from "./litestar-meta.js";
+import { debounce } from "./shared/debounce.js";
 const execAsync = promisify(exec);
 let exitHandlersBound = false;
 const refreshPaths = ["src/**", "resources/**", "assets/**"].filter((path2) => fs.existsSync(path2.replace(/\*\*$/, "")));
@@ -16,13 +17,12 @@ function litestar(config) {
   const pluginConfig = resolvePluginConfig(config);
   const plugins = [resolveLitestarPlugin(pluginConfig), ...resolveFullReloadConfig(pluginConfig)];
   if (pluginConfig.types !== false && pluginConfig.types.enabled) {
-    plugins.push(resolveTypeGenerationPlugin(pluginConfig.types));
+    plugins.push(resolveTypeGenerationPlugin(pluginConfig.types, pluginConfig.executor));
   }
   return plugins;
 }
 async function findIndexHtmlPath(server, pluginConfig) {
   if (!pluginConfig.autoDetectIndex) {
-    console.log("Auto-detection disabled.");
     return null;
   }
   const root = server.config.root;
@@ -42,7 +42,7 @@ async function findIndexHtmlPath(server, pluginConfig) {
   }
   return null;
 }
-function normalizeAppUrl(appUrl, fallbackPort) {
+function normalizeAppUrl(appUrl, _fallbackPort) {
   if (!appUrl || appUrl === "__litestar_app_url_missing__") {
     return { url: null, note: "APP_URL missing" };
   }
@@ -59,6 +59,8 @@ function resolveLitestarPlugin(pluginConfig) {
   let resolvedConfig;
   let userConfig;
   let litestarMeta = {};
+  const pythonDefaults = loadPythonDefaults();
+  const proxyMode = pythonDefaults?.proxyMode ?? "vite_proxy";
   const defaultAliases = {
     "@": `/${pluginConfig.resourceDirectory.replace(/^\/+/, "").replace(/\/+$/, "")}/`
   };
@@ -109,10 +111,19 @@ function resolveLitestarPlugin(pluginConfig) {
               changeOrigin: true
             }
           } : void 0),
+          // Always respect VITE_PORT when set by Python (regardless of VITE_ALLOW_REMOTE)
+          ...process.env.VITE_PORT ? {
+            port: userConfig.server?.port ?? Number.parseInt(process.env.VITE_PORT),
+            strictPort: userConfig.server?.strictPort ?? true
+          } : void 0,
+          // VITE_ALLOW_REMOTE controls host binding (0.0.0.0 for remote access)
+          // Also sets port/strictPort for backwards compatibility when VITE_PORT not set
           ...process.env.VITE_ALLOW_REMOTE ? {
             host: userConfig.server?.host ?? "0.0.0.0",
-            port: userConfig.server?.port ?? (env.VITE_PORT ? Number.parseInt(env.VITE_PORT) : 5173),
-            strictPort: userConfig.server?.strictPort ?? true
+            ...process.env.VITE_PORT ? {} : {
+              port: userConfig.server?.port ?? 5173,
+              strictPort: userConfig.server?.strictPort ?? true
+            }
           } : void 0,
           ...serverConfig ? {
             host: userConfig.server?.host ?? serverConfig.host,
@@ -149,7 +160,7 @@ function resolveLitestarPlugin(pluginConfig) {
       const hint = pluginConfig.types !== false ? pluginConfig.types.routesPath : void 0;
       litestarMeta = await loadLitestarMeta(resolvedConfig, hint);
     },
-    transform(code, id) {
+    transform(code, _id) {
       if (resolvedConfig.command === "serve" && code.includes("__litestar_vite_placeholder__")) {
         const transformedCode = code.replace(/__litestar_vite_placeholder__/g, viteDevServerUrl);
         return pluginConfig.transformOnServe(transformedCode, viteDevServerUrl);
@@ -171,8 +182,10 @@ function resolveLitestarPlugin(pluginConfig) {
         const isAddressInfo = (x) => typeof x === "object";
         if (isAddressInfo(address)) {
           viteDevServerUrl = userConfig.server?.origin ? userConfig.server.origin : resolveDevServerUrl(address, server.config, userConfig);
-          fs.mkdirSync(path.dirname(pluginConfig.hotFile), { recursive: true });
-          fs.writeFileSync(pluginConfig.hotFile, viteDevServerUrl);
+          if (proxyMode !== "external_proxy") {
+            fs.mkdirSync(path.dirname(pluginConfig.hotFile), { recursive: true });
+            fs.writeFileSync(pluginConfig.hotFile, viteDevServerUrl);
+          }
           setTimeout(async () => {
             const version = litestarMeta.litestarVersion ?? process.env.LITESTAR_VERSION ?? "unknown";
             const backendStatus = await checkBackendAvailability(appUrl);
@@ -229,7 +242,7 @@ function resolveLitestarPlugin(pluginConfig) {
           }, 100);
         }
       });
-      if (!exitHandlersBound) {
+      if (!exitHandlersBound && proxyMode !== "external_proxy") {
         const clean = () => {
           if (pluginConfig.hotFile && fs.existsSync(pluginConfig.hotFile)) {
             fs.rmSync(pluginConfig.hotFile);
@@ -291,7 +304,7 @@ function ensureCommandShouldRunInEnvironment(command, env) {
     );
   }
 }
-function pluginVersion() {
+function _pluginVersion() {
   try {
     return JSON.parse(fs.readFileSync(path.join(dirname(), "../package.json")).toString())?.version;
   } catch {
@@ -362,15 +375,23 @@ function resolvePluginConfig(config) {
       debounce: 300
     };
   } else if (typeof resolvedConfig.types === "object" && resolvedConfig.types !== null) {
+    const userProvidedOpenapi = Object.hasOwn(resolvedConfig.types, "openapiPath");
+    const userProvidedRoutes = Object.hasOwn(resolvedConfig.types, "routesPath");
     typesConfig = {
       enabled: resolvedConfig.types.enabled ?? true,
       output: resolvedConfig.types.output ?? "src/generated/types",
-      openapiPath: resolvedConfig.types.openapiPath ?? "src/generated/openapi.json",
-      routesPath: resolvedConfig.types.routesPath ?? "src/generated/routes.json",
+      openapiPath: resolvedConfig.types.openapiPath ?? (resolvedConfig.types.output ? path.join(resolvedConfig.types.output, "openapi.json") : "src/generated/openapi.json"),
+      routesPath: resolvedConfig.types.routesPath ?? (resolvedConfig.types.output ? path.join(resolvedConfig.types.output, "routes.json") : "src/generated/routes.json"),
       generateZod: resolvedConfig.types.generateZod ?? false,
       generateSdk: resolvedConfig.types.generateSdk ?? false,
       debounce: resolvedConfig.types.debounce ?? 300
     };
+    if (!userProvidedOpenapi && resolvedConfig.types.output) {
+      typesConfig.openapiPath = path.join(typesConfig.output, "openapi.json");
+    }
+    if (!userProvidedRoutes && resolvedConfig.types.output) {
+      typesConfig.routesPath = path.join(typesConfig.output, "routes.json");
+    }
   }
   return {
     input: resolvedConfig.input,
@@ -384,10 +405,11 @@ function resolvePluginConfig(config) {
     detectTls: resolvedConfig.detectTls ?? false,
     autoDetectIndex: resolvedConfig.autoDetectIndex ?? true,
     transformOnServe: resolvedConfig.transformOnServe ?? ((code) => code),
-    types: typesConfig
+    types: typesConfig,
+    executor: resolvedConfig.executor ?? pythonDefaults?.executor
   };
 }
-function resolveBase(config, assetUrl) {
+function resolveBase(_config, assetUrl) {
   if (process.env.NODE_ENV === "development") {
     return assetUrl;
   }
@@ -424,15 +446,6 @@ function resolveFullReloadConfig({ refresh: config }) {
     return plugin;
   });
 }
-function debounce(func, wait) {
-  let timeout = null;
-  return (...args) => {
-    if (timeout) {
-      clearTimeout(timeout);
-    }
-    timeout = setTimeout(() => func(...args), wait);
-  };
-}
 async function emitRouteTypes(routesPath, outputDir) {
   const contents = await fs.promises.readFile(routesPath, "utf-8");
   const json = JSON.parse(contents);
@@ -558,7 +571,7 @@ export { getCsrfToken, csrfHeaders, csrfFetch } from "litestar-vite-plugin/helpe
 `;
   await fs.promises.writeFile(outFile, `${banner}${body}`, "utf-8");
 }
-function resolveTypeGenerationPlugin(typesConfig) {
+function resolveTypeGenerationPlugin(typesConfig, executor) {
   let lastTypesHash = null;
   let lastRoutesHash = null;
   let server = null;
@@ -580,12 +593,12 @@ function resolveTypeGenerationPlugin(typesConfig) {
         }
         const args = ["@hey-api/openapi-ts", "-i", typesConfig.openapiPath, "-o", typesConfig.output];
         if (typesConfig.generateZod) {
-          args.push("--plugins", "@hey-api/schemas", "@hey-api/types");
+          args.push("--plugins", "zod", "@hey-api/typescript");
         }
         if (typesConfig.generateSdk) {
           args.push("--client", "fetch");
         }
-        await execAsync(`npx ${args.join(" ")}`, {
+        await execAsync(resolvePackageExecutor(args.join(" "), executor), {
           cwd: process.cwd()
         });
         generated = true;

package/dist/js/inertia-helpers/{inertia-helpers/index.d.ts → index.d.ts}

@@ -6,11 +6,22 @@
  *
  * @module
  */
-export { getCsrfToken, csrfHeaders, csrfFetch, route, getRoutes, toRoute, currentRoute, isRoute, isCurrentRoute, getRelativeUrlPath, type RouteDefinition, type RoutesMap, } from "../helpers/index.js";
+export { csrfFetch, csrfHeaders, currentRoute, getCsrfToken, getRelativeUrlPath, getRoutes, isCurrentRoute, isRoute, type RouteDefinition, type RoutesMap, route, toRoute, } from "litestar-vite-plugin/helpers";
+/**
+ * Unwrap page props that may have content nested under "content" key.
+ *
+ * Litestar wraps route return values under `content`. This utility
+ * spreads the content at the top level for ergonomic prop access.
+ *
+ * @param props - The raw page props from Inertia
+ * @returns Props with content unwrapped if applicable
+ */
+export declare function unwrapPageProps<T extends Record<string, unknown>>(props: T): T;
 /**
  * Resolve a page component from a glob import.
  *
  * Used with Inertia.js to dynamically import page components.
+ * Automatically unwraps Litestar's `content` prop for ergonomic access.
  *
  * @param path - Component path or array of paths to try
  * @param pages - Glob import result (e.g., import.meta.glob('./pages/**\/*.vue'))

package/dist/js/inertia-helpers/index.js

@@ -0,0 +1,91 @@
+/**
+ * Inertia.js helpers for Litestar applications.
+ *
+ * This module re-exports common helpers from litestar-vite-plugin/helpers
+ * and adds Inertia-specific utilities.
+ *
+ * @module
+ */
+// Re-export all helpers from the main helpers module
+// Note: Using package path instead of relative import to ensure proper build output structure
+export { csrfFetch, csrfHeaders, currentRoute, 
+// CSRF utilities
+getCsrfToken, getRelativeUrlPath, getRoutes, isCurrentRoute, isRoute, 
+// Route utilities
+route, toRoute, } from "litestar-vite-plugin/helpers";
+/**
+ * Unwrap page props that may have content nested under "content" key.
+ *
+ * Litestar wraps route return values under `content`. This utility
+ * spreads the content at the top level for ergonomic prop access.
+ *
+ * @param props - The raw page props from Inertia
+ * @returns Props with content unwrapped if applicable
+ */
+export function unwrapPageProps(props) {
+    if (props.content !== undefined && props.content !== null && typeof props.content === "object" && !Array.isArray(props.content)) {
+        const { content, ...rest } = props;
+        return { ...rest, ...content };
+    }
+    return props;
+}
+/**
+ * Wrap a component to automatically unwrap Litestar's content prop.
+ *
+ * @param component - The original component (function or object with default)
+ * @returns Wrapped component that transforms props
+ */
+function wrapComponent(module) {
+    // Handle ES module with default export
+    const mod = module;
+    if (mod.default && typeof mod.default === "function") {
+        const Original = mod.default;
+        const Wrapped = (props) => Original(unwrapPageProps(props));
+        // Copy static properties (displayName, layout, etc.)
+        Object.assign(Wrapped, Original);
+        return { ...mod, default: Wrapped };
+    }
+    // Handle direct function export
+    if (typeof module === "function") {
+        const Original = module;
+        const Wrapped = (props) => Original(unwrapPageProps(props));
+        Object.assign(Wrapped, Original);
+        return Wrapped;
+    }
+    return module;
+}
+/**
+ * Resolve a page component from a glob import.
+ *
+ * Used with Inertia.js to dynamically import page components.
+ * Automatically unwraps Litestar's `content` prop for ergonomic access.
+ *
+ * @param path - Component path or array of paths to try
+ * @param pages - Glob import result (e.g., import.meta.glob('./pages/**\/*.vue'))
+ * @returns Promise resolving to the component
+ * @throws Error if no matching component is found
+ *
+ * @example
+ * ```ts
+ * import { resolvePageComponent } from 'litestar-vite-plugin/inertia-helpers'
+ *
+ * createInertiaApp({
+ *   resolve: (name) => resolvePageComponent(
+ *     `./pages/${name}.vue`,
+ *     import.meta.glob('./pages/**\/*.vue')
+ *   ),
+ *   // ...
+ * })
+ * ```
+ */
+export async function resolvePageComponent(path, pages) {
+    for (const p of Array.isArray(path) ? path : [path]) {
+        const page = pages[p];
+        if (typeof page === "undefined") {
+            continue;
+        }
+        const resolved = typeof page === "function" ? await page() : await page;
+        return wrapComponent(resolved);
+    }
+    throw new Error(`Page not found: ${path}`);
+}

package/dist/js/install-hint.d.ts

@@ -1 +1,10 @@
 export declare function resolveInstallHint(pkg?: string): string;
+/**
+ * Resolves the package executor command based on runtime.
+ * Priority: explicit executor > LITESTAR_VITE_RUNTIME env > 'node' default
+ *
+ * @param pkg - The package command to execute (e.g., "@hey-api/openapi-ts -i schema.json -o src/types")
+ * @param executor - Optional explicit executor override
+ * @returns The full command string (e.g., "npx @hey-api/openapi-ts ..." or "bunx @hey-api/openapi-ts ...")
+ */
+export declare function resolvePackageExecutor(pkg: string, executor?: string): string;

package/dist/js/install-hint.js

@@ -16,6 +16,22 @@ function resolveInstallHint(pkg = "@hey-api/openapi-ts") {
   }
   return `npm install -D ${pkg}`;
 }
+function resolvePackageExecutor(pkg, executor) {
+  const runtime = (executor ?? process.env.LITESTAR_VITE_RUNTIME ?? "").toLowerCase();
+  switch (runtime) {
+    case "bun":
+      return `bunx ${pkg}`;
+    case "deno":
+      return `deno run -A npm:${pkg}`;
+    case "pnpm":
+      return `pnpm dlx ${pkg}`;
+    case "yarn":
+      return `yarn dlx ${pkg}`;
+    default:
+      return `npx ${pkg}`;
+  }
+}
 export {
-  resolveInstallHint
+  resolveInstallHint,
+  resolvePackageExecutor
 };

package/dist/js/nuxt.d.ts

@@ -102,6 +102,13 @@ export interface LitestarNuxtConfig {
      * @default false
      */
     verbose?: boolean;
+    /**
+     * JavaScript runtime executor for package commands.
+     * Used when running tools like @hey-api/openapi-ts.
+     *
+     * @default undefined (uses LITESTAR_VITE_RUNTIME env or 'node')
+     */
+    executor?: "node" | "bun" | "deno" | "yarn" | "pnpm";
 }
 /**
  * Litestar Vite plugins for Nuxt.
@@ -133,8 +140,7 @@ export declare function litestarPlugins(userConfig?: LitestarNuxtConfig): Plugin
 /**
  * Nuxt module definition for Litestar integration.
  *
- * This is a minimal module interface that can be used with Nuxt's module system.
- * For full type safety, install @nuxt/kit as a dev dependency.
+ * This is a function-based module that works with Nuxt's module system.
  *
  * @example
  * ```typescript
@@ -164,30 +170,31 @@ export declare function litestarPlugins(userConfig?: LitestarNuxtConfig): Plugin
  * }
  * ```
  */
-export declare const litestarModule: {
-    meta: {
+interface NuxtModuleFunction {
+    (userOptions: LitestarNuxtConfig, nuxt: NuxtContext): void | Promise<void>;
+    meta?: {
         name: string;
         configKey: string;
-        compatibility: {
+        compatibility?: {
             nuxt: string;
         };
     };
-    defaults: {
-        apiProxy: string;
-        apiPrefix: string;
-        types: false;
-        verbose: false;
-    };
-    /**
-     * Setup function for the Nuxt module.
-     * This is called by Nuxt when the module is loaded.
-     */
-    setup(userOptions: LitestarNuxtConfig, nuxt: {
-        options: {
-            vite: {
-                plugins?: Plugin[];
-            };
+    getOptions?: () => LitestarNuxtConfig;
+}
+interface NuxtContext {
+    options: {
+        vite: {
+            plugins?: Plugin[];
+        };
+        runtimeConfig?: {
+            public?: Record<string, unknown>;
+        };
+        nitro?: {
+            devProxy?: Record<string, unknown>;
         };
-    }): void;
-};
+        litestar?: LitestarNuxtConfig;
+    };
+    hook?: (name: string, fn: (...args: unknown[]) => void | Promise<void>) => void;
+}
+export declare const litestarModule: NuxtModuleFunction;
 export default litestarModule;