litestar-vite-plugin 0.15.0-alpha.1 → 0.15.0-alpha.3

package/README.md

@@ -5,14 +5,16 @@ Litestar Vite connects the Litestar backend to a Vite toolchain. It supports SPA
 ## Features
 
 - One-port dev: proxies Vite HTTP + WS/HMR through Litestar by default; switch to two-port with `VITE_PROXY_MODE=direct`.
+- SSR framework support: use `proxy_mode="ssr"` for Astro, Nuxt, SvelteKit - proxies everything except your API routes.
 - Production assets: reads Vite manifest from `public/manifest.json` (configurable) and serves under `asset_url`.
 - Type-safe frontends: optional OpenAPI/routes export + `@hey-api/openapi-ts` via the Vite plugin.
 - Inertia support: v2 protocol with session middleware and optional SPA mode.
 
-## Quick start (SPA)
+## Quick start (React TanStack SPA)
 
 ```bash
 pip install litestar-vite
+litestar assets init --template react-tanstack
 litestar assets install  # installs frontend deps via configured executor
 ```
 
@@ -20,13 +22,15 @@ litestar assets install  # installs frontend deps via configured executor
 from litestar import Litestar
 from litestar_vite import VitePlugin, ViteConfig
 
-app = Litestar(plugins=[VitePlugin(config=ViteConfig(dev_mode=True))])
+app = Litestar(plugins=[VitePlugin(config=ViteConfig(dev_mode=True))])  # SPA mode by default
 ```
 
 ```bash
-litestar run  # starts Litestar; Vite dev is proxied automatically
+litestar run --reload  # starts Litestar; Vite dev is proxied automatically
 ```
 
+Other templates: `react`, `vue`, `svelte`, `htmx`, `react-inertia`, `vue-inertia`, `svelte-inertia`, `angular`, `angular-cli`, `astro`, `nuxt`, `sveltekit` (see `litestar assets init --help`).
+
 ## Template / HTMX
 
 ```python
@@ -47,13 +51,15 @@ Requires session middleware.
 
 ```python
 from litestar import Litestar
-from litestar.middleware.session.server_side import ServerSideSessionConfig, ServerSideSessionMiddleware
+from litestar.middleware.session.client_side import CookieBackendConfig
 from litestar_vite import VitePlugin, ViteConfig
 from litestar_vite.inertia import InertiaPlugin
 from litestar_vite.inertia.config import InertiaConfig
 
+session_backend = CookieBackendConfig(secret="dev-secret")
+
 app = Litestar(
-    middleware=[ServerSideSessionMiddleware(config=ServerSideSessionConfig(secret="secret"))],
+    middleware=[session_backend.middleware],
     plugins=[
         VitePlugin(config=ViteConfig(mode="template", inertia=True, dev_mode=True)),
         InertiaPlugin(InertiaConfig()),
@@ -61,6 +67,62 @@ app = Litestar(
 )
 ```
 
+## SSR Frameworks (Astro, Nuxt, SvelteKit)
+
+For SSR frameworks that handle their own routing, use `proxy_mode="ssr"`:
+
+```python
+import os
+from pathlib import Path
+from litestar import Litestar
+from litestar_vite import VitePlugin, ViteConfig, PathConfig, RuntimeConfig
+
+DEV_MODE = os.getenv("VITE_DEV_MODE", "true").lower() in ("true", "1", "yes")
+
+app = Litestar(
+    plugins=[
+        VitePlugin(config=ViteConfig(
+            dev_mode=DEV_MODE,
+            paths=PathConfig(root=Path(__file__).parent),
+            runtime=RuntimeConfig(
+                proxy_mode="ssr" if DEV_MODE else None,  # Proxy in dev, static in prod
+                spa_handler=not DEV_MODE,  # Serve built files in production
+            ),
+        ))
+    ],
+)
+```
+
+### Proxy Modes
+
+| Mode | Alias | Use Case |
+|------|-------|----------|
+| `vite` | - | SPAs - proxies Vite assets only (default) |
+| `direct` | - | Two-port dev - expose Vite port directly |
+| `proxy` | `ssr` | SSR frameworks - proxies everything except API routes |
+
+### Production Deployment
+
+**Static Build (recommended):** Build your SSR framework to static files, then serve with Litestar:
+
+```bash
+# Build frontend
+cd examples/astro && npm run build
+
+# Run in production mode
+VITE_DEV_MODE=false litestar --app-dir examples/astro run
+```
+
+Configure `bundle_dir` to match your framework's build output:
+
+| Framework | Default Output | PathConfig |
+|-----------|---------------|------------|
+| Astro | `dist/` | `bundle_dir=Path("dist")` |
+| Nuxt | `.output/public/` | `bundle_dir=Path(".output/public")` |
+| SvelteKit | `build/` | `bundle_dir=Path("build")` |
+
+**Two-Service:** For dynamic SSR, run the Node server alongside Litestar behind a reverse proxy.
+
 ## Type generation
 
 ```python
@@ -89,5 +151,5 @@ litestar assets generate-types  # one-off or CI
 ## Links
 
 - Docs: <https://litestar-org.github.io/litestar-vite/>
-- Examples: `examples/` (basic, inertia, spa-react)
+- Examples: `examples/` (basic, inertia, react)
 - Issues: <https://github.com/litestar-org/litestar-vite/issues/>

package/dist/js/astro.d.ts

@@ -17,7 +17,10 @@
  *   integrations: [
  *     litestar({
  *       apiProxy: 'http://localhost:8000',
- *       typesPath: './src/generated/api',
+ *       types: {
+ *         enabled: true,
+ *         output: 'src/generated/api',
+ *       },
  *     }),
  *   ],
  * });
@@ -31,6 +34,31 @@ import type { Plugin, ViteDevServer } from "vite";
  * This is a minimal type definition to avoid requiring astro as a dependency.
  * When using this integration, Astro will be available in the project.
  */
+/**
+ * Astro config for updateConfig - partial types we support.
+ */
+interface AstroConfigPartial {
+    server?: {
+        port?: number;
+        host?: string | boolean;
+    };
+    vite?: {
+        plugins?: Plugin[];
+        server?: {
+            port?: number;
+            strictPort?: boolean;
+            proxy?: Record<string, unknown>;
+        };
+    };
+}
+/**
+ * AddressInfo from Node.js net module.
+ */
+interface AddressInfo {
+    address: string;
+    family: string;
+    port: number;
+}
 interface AstroIntegration {
     name: string;
     hooks: {
@@ -38,17 +66,17 @@ interface AstroIntegration {
             config: unknown;
             command: "dev" | "build" | "preview" | "sync";
             isRestart: boolean;
-            updateConfig: (newConfig: {
-                vite?: {
-                    plugins?: Plugin[];
-                };
-            }) => unknown;
+            updateConfig: (newConfig: AstroConfigPartial) => unknown;
             logger: AstroIntegrationLogger;
         }) => void | Promise<void>;
         "astro:server:setup"?: (options: {
             server: ViteDevServer;
             logger: AstroIntegrationLogger;
         }) => void | Promise<void>;
+        "astro:server:start"?: (options: {
+            address: AddressInfo;
+            logger: AstroIntegrationLogger;
+        }) => void | Promise<void>;
         "astro:build:start"?: (options: {
             logger: AstroIntegrationLogger;
         }) => void | Promise<void>;
@@ -62,6 +90,48 @@ interface AstroIntegrationLogger {
     warn: (message: string) => void;
     error: (message: string) => void;
 }
+/**
+ * Configuration for TypeScript type generation in Astro.
+ */
+export interface AstroTypesConfig {
+    /**
+     * Enable type generation.
+     *
+     * @default false
+     */
+    enabled?: boolean;
+    /**
+     * Path to output generated TypeScript types.
+     * Relative to the Astro project root.
+     *
+     * @default 'src/types/api'
+     */
+    output?: string;
+    /**
+     * Path where the OpenAPI schema is exported by Litestar.
+     *
+     * @default 'openapi.json'
+     */
+    openapiPath?: string;
+    /**
+     * Path where route metadata is exported by Litestar.
+     *
+     * @default 'routes.json'
+     */
+    routesPath?: string;
+    /**
+     * Generate Zod schemas in addition to TypeScript types.
+     *
+     * @default false
+     */
+    generateZod?: boolean;
+    /**
+     * Debounce time in milliseconds for type regeneration.
+     *
+     * @default 300
+     */
+    debounce?: number;
+}
 /**
  * Configuration options for the Litestar Astro integration.
  */
@@ -82,25 +152,14 @@ export interface LitestarAstroConfig {
      */
     apiPrefix?: string;
     /**
-     * Path where TypeScript types are generated.
-     * This should match the output path configured in your Litestar ViteConfig.
+     * Enable and configure TypeScript type generation.
      *
-     * @example './src/generated/api'
-     * @default './src/types/api'
-     */
-    typesPath?: string;
-    /**
-     * Path to the OpenAPI schema file exported by Litestar.
+     * When set to `true`, enables type generation with default settings.
+     * When set to an AstroTypesConfig object, enables type generation with custom settings.
      *
-     * @default 'openapi.json'
-     */
-    openapiPath?: string;
-    /**
-     * Path to the routes metadata file exported by Litestar.
-     *
-     * @default 'routes.json'
+     * @default false
      */
-    routesPath?: string;
+    types?: boolean | AstroTypesConfig;
     /**
      * Enable verbose logging for debugging.
      *
@@ -128,7 +187,10 @@ export interface LitestarAstroConfig {
  *     litestar({
  *       apiProxy: 'http://localhost:8000',
  *       apiPrefix: '/api',
- *       typesPath: './src/generated/api',
+ *       types: {
+ *         enabled: true,
+ *         output: 'src/generated/api',
+ *       },
  *     }),
  *   ],
  * });

package/dist/js/astro.js

@@ -1,11 +1,65 @@
+import { exec } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { promisify } from "node:util";
+import colors from "picocolors";
+import { resolveInstallHint } from "./install-hint.js";
+import { debounce } from "./shared/debounce.js";
+const execAsync = promisify(exec);
 function resolveConfig(config = {}) {
+  const runtimeConfigPath = process.env.LITESTAR_VITE_CONFIG_PATH;
+  let hotFile;
+  let proxyMode = "vite";
+  let port;
+  const envPort = process.env.VITE_PORT;
+  if (envPort) {
+    port = Number.parseInt(envPort, 10);
+    if (Number.isNaN(port)) {
+      port = void 0;
+    }
+  }
+  if (runtimeConfigPath && fs.existsSync(runtimeConfigPath)) {
+    try {
+      const json = JSON.parse(fs.readFileSync(runtimeConfigPath, "utf-8"));
+      const bundleDir = json.bundleDir ?? "public";
+      const hot = json.hotFile ?? "hot";
+      hotFile = path.resolve(process.cwd(), bundleDir, hot);
+      proxyMode = json.proxyMode ?? "vite";
+      if (json.port !== void 0) {
+        port = json.port;
+      }
+    } catch {
+      hotFile = void 0;
+    }
+  }
+  let typesConfig = false;
+  if (config.types === true) {
+    typesConfig = {
+      enabled: true,
+      output: "src/types/api",
+      openapiPath: "openapi.json",
+      routesPath: "routes.json",
+      generateZod: false,
+      debounce: 300
+    };
+  } else if (typeof config.types === "object" && config.types !== null) {
+    typesConfig = {
+      enabled: config.types.enabled ?? true,
+      output: config.types.output ?? "src/types/api",
+      openapiPath: config.types.openapiPath ?? "openapi.json",
+      routesPath: config.types.routesPath ?? "routes.json",
+      generateZod: config.types.generateZod ?? false,
+      debounce: config.types.debounce ?? 300
+    };
+  }
   return {
     apiProxy: config.apiProxy ?? "http://localhost:8000",
     apiPrefix: config.apiPrefix ?? "/api",
-    typesPath: config.typesPath ?? "./src/types/api",
-    openapiPath: config.openapiPath ?? "openapi.json",
-    routesPath: config.routesPath ?? "routes.json",
-    verbose: config.verbose ?? false
+    types: typesConfig,
+    verbose: config.verbose ?? false,
+    hotFile,
+    proxyMode,
+    port
   };
 }
 function createProxyPlugin(config) {
@@ -14,6 +68,12 @@ function createProxyPlugin(config) {
     config() {
       return {
         server: {
+          // Set the port from Python config/env to ensure Astro uses the expected port
+          // strictPort: true prevents Astro from auto-incrementing to a different port
+          ...config.port !== void 0 ? {
+            port: config.port,
+            strictPort: true
+          } : {},
           proxy: {
             [config.apiPrefix]: {
               target: config.apiProxy,
@@ -26,23 +86,240 @@ function createProxyPlugin(config) {
     }
   };
 }
+async function emitRouteTypes(routesPath, outputDir) {
+  const contents = await fs.promises.readFile(routesPath, "utf-8");
+  const json = JSON.parse(contents);
+  const outDir = path.resolve(process.cwd(), outputDir);
+  await fs.promises.mkdir(outDir, { recursive: true });
+  const outFile = path.join(outDir, "routes.ts");
+  const banner = `// AUTO-GENERATED by litestar-vite. Do not edit.
+/* eslint-disable */
+
+`;
+  const routesData = json.routes || json;
+  const routeNames = Object.keys(routesData);
+  const routeNameType = routeNames.length > 0 ? routeNames.map((n) => `"${n}"`).join(" | ") : "never";
+  const routeParamTypes = [];
+  for (const [name, data] of Object.entries(routesData)) {
+    const routeData = data;
+    if (routeData.parameters && routeData.parameters.length > 0) {
+      const params = routeData.parameters.map((p) => `${p}: string | number`).join("; ");
+      routeParamTypes.push(`  "${name}": { ${params} }`);
+    } else {
+      routeParamTypes.push(`  "${name}": Record<string, never>`);
+    }
+  }
+  const body = `/**
+ * AUTO-GENERATED by litestar-vite.
+ *
+ * Exports:
+ * - routesMeta: full route metadata
+ * - routes: name -> uri map
+ * - serverRoutes: alias of routes for clarity in apps
+ * - route(): type-safe URL generator
+ * - hasRoute(): type guard
+ * - csrf helpers re-exported from litestar-vite-plugin/helpers
+ *
+ * @see https://litestar-vite.litestar.dev/
+ */
+export const routesMeta = ${JSON.stringify(json, null, 2)} as const
+
+/**
+ * Route name to URI mapping.
+ */
+export const routes = ${JSON.stringify(Object.fromEntries(Object.entries(routesData).map(([name, data]) => [name, data.uri])), null, 2)} as const
+
+/**
+ * Alias for server-injected route map (more descriptive for consumers).
+ */
+export const serverRoutes = routes
+
+/**
+ * All available route names.
+ */
+export type RouteName = ${routeNameType}
+
+/**
+ * Parameter types for each route.
+ */
+export interface RouteParams {
+${routeParamTypes.join("\n")}
+}
+
+/**
+ * Generate a URL for a named route with type-safe parameters.
+ *
+ * @param name - The route name
+ * @param params - Route parameters (required if route has path parameters)
+ * @returns The generated URL
+ *
+ * @example
+ * \`\`\`ts
+ * import { route } from '@/generated/routes'
+ *
+ * // Route without parameters
+ * route('home')  // "/"
+ *
+ * // Route with parameters
+ * route('user:detail', { user_id: 123 })  // "/users/123"
+ * \`\`\`
+ */
+export function route<T extends RouteName>(
+  name: T,
+  ...args: RouteParams[T] extends Record<string, never> ? [] : [params: RouteParams[T]]
+): string {
+  let uri = routes[name] as string
+  const params = args[0] as Record<string, string | number> | undefined
+
+  if (params) {
+    for (const [key, value] of Object.entries(params)) {
+      // Handle both {param} and {param:type} syntax
+      uri = uri.replace(new RegExp(\`\\\\{\${key}(?::[^}]+)?\\\\}\`, "g"), String(value))
+    }
+  }
+
+  return uri
+}
+
+/**
+ * Check if a route name exists.
+ */
+export function hasRoute(name: string): name is RouteName {
+  return name in routes
+}
+
+declare global {
+  interface Window {
+    /**
+     * Fully-typed route metadata injected by Litestar.
+     */
+    __LITESTAR_ROUTES__?: typeof routesMeta
+    /**
+     * Simple route map (name -> uri) for legacy consumers.
+     */
+    routes?: typeof routes
+    serverRoutes?: typeof serverRoutes
+  }
+  // eslint-disable-next-line no-var
+  var routes: typeof routes | undefined
+  var serverRoutes: typeof serverRoutes | undefined
+}
+
+// Re-export helper functions from litestar-vite-plugin
+// These work with the routes defined above
+export { getCsrfToken, csrfHeaders, csrfFetch } from "litestar-vite-plugin/helpers"
+`;
+  await fs.promises.writeFile(outFile, `${banner}${body}`, "utf-8");
+}
+function createTypeGenerationPlugin(typesConfig) {
+  let server = null;
+  let isGenerating = false;
+  async function runTypeGeneration() {
+    if (isGenerating) {
+      return false;
+    }
+    isGenerating = true;
+    const startTime = Date.now();
+    try {
+      const openapiPath = path.resolve(process.cwd(), typesConfig.openapiPath);
+      if (!fs.existsSync(openapiPath)) {
+        console.log(colors.cyan("[litestar-astro]"), colors.yellow("OpenAPI schema not found:"), typesConfig.openapiPath);
+        return false;
+      }
+      console.log(colors.cyan("[litestar-astro]"), colors.dim("Generating TypeScript types..."));
+      const args = ["@hey-api/openapi-ts", "-i", typesConfig.openapiPath, "-o", typesConfig.output];
+      if (typesConfig.generateZod) {
+        args.push("--plugins", "zod", "@hey-api/typescript");
+      }
+      await execAsync(`npx ${args.join(" ")}`, {
+        cwd: process.cwd()
+      });
+      const routesPath = path.resolve(process.cwd(), typesConfig.routesPath);
+      if (fs.existsSync(routesPath)) {
+        await emitRouteTypes(routesPath, typesConfig.output);
+      }
+      const duration = Date.now() - startTime;
+      console.log(colors.cyan("[litestar-astro]"), colors.green("Types generated"), colors.dim(`in ${duration}ms`));
+      if (server) {
+        server.ws.send({
+          type: "custom",
+          event: "litestar:types-updated",
+          data: {
+            output: typesConfig.output,
+            timestamp: Date.now()
+          }
+        });
+      }
+      return true;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (message.includes("not found") || message.includes("ENOENT")) {
+        console.log(colors.cyan("[litestar-astro]"), colors.yellow("@hey-api/openapi-ts not installed"), "- run:", resolveInstallHint());
+      } else {
+        console.error(colors.cyan("[litestar-astro]"), colors.red("Type generation failed:"), message);
+      }
+      return false;
+    } finally {
+      isGenerating = false;
+    }
+  }
+  const debouncedRunTypeGeneration = debounce(runTypeGeneration, typesConfig.debounce);
+  return {
+    name: "litestar-astro-types",
+    enforce: "pre",
+    configureServer(devServer) {
+      server = devServer;
+      console.log(colors.cyan("[litestar-astro]"), colors.dim("Watching for schema changes:"), colors.yellow(typesConfig.openapiPath));
+    },
+    handleHotUpdate({ file }) {
+      if (!typesConfig.enabled) {
+        return;
+      }
+      const relativePath = path.relative(process.cwd(), file);
+      const openapiPath = typesConfig.openapiPath.replace(/^\.\//, "");
+      const routesPath = typesConfig.routesPath.replace(/^\.\//, "");
+      if (relativePath === openapiPath || relativePath === routesPath || file.endsWith(openapiPath) || file.endsWith(routesPath)) {
+        console.log(colors.cyan("[litestar-astro]"), colors.dim("Schema changed:"), colors.yellow(relativePath));
+        debouncedRunTypeGeneration();
+      }
+    }
+  };
+}
 function litestarAstro(userConfig = {}) {
   const config = resolveConfig(userConfig);
   return {
     name: "litestar-vite",
     hooks: {
-      "astro:config:setup": ({ updateConfig, logger }) => {
+      "astro:config:setup": ({ updateConfig, logger, command }) => {
         if (config.verbose) {
           logger.info("Configuring Litestar integration");
           logger.info(`  API Proxy: ${config.apiProxy}`);
           logger.info(`  API Prefix: ${config.apiPrefix}`);
-          logger.info(`  Types Path: ${config.typesPath}`);
+          if (config.types !== false) {
+            logger.info(`  Types Output: ${config.types.output}`);
+          }
+          if (config.port !== void 0) {
+            logger.info(`  Port: ${config.port}`);
+          }
+        }
+        const plugins = [createProxyPlugin(config)];
+        if (config.types !== false && config.types.enabled) {
+          plugins.push(createTypeGenerationPlugin(config.types));
         }
-        updateConfig({
+        const configUpdate = {
           vite: {
-            plugins: [createProxyPlugin(config)]
+            plugins
           }
-        });
+        };
+        if (command === "dev" && config.port !== void 0) {
+          configUpdate.server = {
+            port: config.port
+          };
+          if (config.verbose) {
+            logger.info(`Setting Astro server port to ${config.port}`);
+          }
+        }
+        updateConfig(configUpdate);
         logger.info(`Litestar integration configured - proxying ${config.apiPrefix}/* to ${config.apiProxy}`);
       },
       "astro:server:setup": ({ server, logger }) => {
@@ -58,6 +335,20 @@ function litestarAstro(userConfig = {}) {
           });
         }
       },
+      // Write hotfile AFTER server starts listening (astro:server:start fires after listen())
+      // Always write hotfile - proxy mode needs it for dynamic target discovery
+      "astro:server:start": ({ address, logger }) => {
+        if (config.hotFile) {
+          const rawAddr = address.address;
+          const host = rawAddr === "::" || rawAddr === "::1" || rawAddr === "0.0.0.0" || rawAddr === "127.0.0.1" ? "localhost" : rawAddr;
+          const url = `http://${host}:${address.port}`;
+          fs.mkdirSync(path.dirname(config.hotFile), { recursive: true });
+          fs.writeFileSync(config.hotFile, url);
+          if (config.verbose) {
+            logger.info(`Hotfile written: ${config.hotFile} -> ${url}`);
+          }
+        }
+      },
       "astro:build:start": ({ logger }) => {
         logger.info("Building with Litestar integration");
         logger.info(`  Make sure your Litestar backend is accessible at: ${config.apiProxy}`);

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

@@ -21,4 +21,4 @@
  * @module
  */
 export { getCsrfToken, csrfHeaders, csrfFetch } from "./csrf.js";
-export { route, getRoutes, toRoute, currentRoute, isRoute, isCurrentRoute, getRelativeUrlPath, type RouteDefinition, type RoutesMap, } from "./routes.js";
+export { route, getRoutes, toRoute, currentRoute, isRoute, isCurrentRoute, getRelativeUrlPath, LITESTAR, type RouteDefinition, type RoutesMap, type LitestarHelpers, } from "./routes.js";

package/dist/js/helpers/index.js

@@ -23,4 +23,4 @@
 // CSRF utilities
 export { getCsrfToken, csrfHeaders, csrfFetch } from "./csrf.js";
 // Route utilities
-export { route, getRoutes, toRoute, currentRoute, isRoute, isCurrentRoute, getRelativeUrlPath, } from "./routes.js";
+export { route, getRoutes, toRoute, currentRoute, isRoute, isCurrentRoute, getRelativeUrlPath, LITESTAR, } from "./routes.js";

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 {};