@useavalon/avalon 0.1.23 → 0.1.24

package/dist/src/nitro/types.d.ts

@@ -0,0 +1,278 @@
+/**
+ * Nitro Types and Interfaces for Avalon
+ *
+ * This module defines the core types used throughout the Nitro integration,
+ * including render context, runtime configuration, and route definitions.
+ *
+ * In Nitro v3, canonical types should be imported from `nitro/types`.
+ * Avalon-specific types that extend or complement Nitro's types are defined here.
+ */
+import type { MiddlewareContext } from '../nitro/middleware-adapter.ts';
+import type { ApiMethod } from '../schemas/api.ts';
+/**
+ * ServerRequest type reference from Nitro v3 (`nitro/types`).
+ * Re-exported here for convenience within Avalon's Nitro integration.
+ *
+ * Represents the server-side request object in Nitro v3's type system.
+ * When the full `nitro/types` package is available, prefer importing directly.
+ */
+export interface ServerRequest {
+    /** HTTP method */
+    method: string;
+    /** Request URL */
+    url: string;
+    /** Request headers */
+    headers: Record<string, string | string[] | undefined>;
+    /** Request body (if applicable) */
+    body?: unknown;
+}
+/**
+ * H3 Event type placeholder
+ * This represents the H3 event object from Nitro's h3 library
+ */
+export interface H3Event {
+    /** HTTP method */
+    method: string;
+    /** Node.js request object */
+    node?: {
+        req: unknown;
+        res?: unknown;
+    };
+    /** Event context for storing data */
+    context: Record<string, unknown>;
+    /** Request path */
+    path: string;
+}
+/**
+ * Avalon-specific runtime configuration stored in Nitro's runtimeConfig
+ * This is accessed via useRuntimeConfig().avalon in handlers
+ */
+export interface AvalonRuntimeConfig {
+    /** Enable streaming SSR responses */
+    streaming: boolean;
+    /** Pages directory path relative to project root */
+    pagesDir: string;
+    /** Layouts directory path relative to project root */
+    layoutsDir: string;
+    /** Source directory path relative to project root */
+    srcDir?: string;
+}
+/**
+ * Render context provided to the SSR renderer
+ * Contains all information needed to render a page
+ */
+export interface NitroRenderContext {
+    /** Request URL */
+    url: URL;
+    /** Route parameters extracted from dynamic segments */
+    params: Record<string, string>;
+    /** Query parameters from URL search string */
+    query: Record<string, string | string[]>;
+    /** Original HTTP request */
+    request: Request;
+    /** H3 event for advanced use cases */
+    event: H3Event;
+    /** Middleware context if middleware was executed */
+    middlewareContext?: MiddlewareContext;
+    /** Layout context for rendering */
+    layoutContext?: LayoutContext;
+}
+/**
+ * Layout context for page rendering
+ */
+export interface LayoutContext {
+    /** Layout component paths in nesting order (outermost first) */
+    layouts: string[];
+    /** Layout data loaded from layout modules */
+    layoutData?: Record<string, unknown>;
+}
+/**
+ * Discovered route information
+ */
+export interface DiscoveredRoute {
+    /** Route type: page or API */
+    type: 'page' | 'api';
+    /** Absolute file path to the route handler */
+    filePath: string;
+    /** Route pattern for matching (e.g., /users/:id) */
+    pattern: string;
+    /** Extracted parameter names from dynamic segments */
+    params: string[];
+    /** HTTP method for API routes with method suffix */
+    method?: ApiMethod;
+}
+/**
+ * Nitro route configuration
+ */
+export interface NitroRouteConfig {
+    /** Route pattern (e.g., /users/:id) */
+    pattern: string;
+    /** Route handler type */
+    type: 'page' | 'api' | 'middleware';
+    /** File path to the handler */
+    filePath: string;
+    /** Extracted parameter names */
+    params: string[];
+    /** HTTP method (for API routes) */
+    method?: ApiMethod;
+    /** Layout chain for pages */
+    layouts?: string[];
+}
+/**
+ * SSR render options
+ */
+export interface SSRRenderOptions {
+    /** Enable streaming SSR */
+    streaming?: boolean;
+    /** Callback when shell is ready (for streaming) */
+    onShellReady?: () => void;
+    /** Callback when all content is ready */
+    onAllReady?: () => void;
+    /** Callback on render error */
+    onError?: (error: Error) => void;
+}
+/**
+ * SSR render result
+ */
+export interface SSRRenderResult {
+    /** Rendered HTML string or stream */
+    html: string | ReadableStream<Uint8Array>;
+    /** HTTP status code */
+    statusCode: number;
+    /** Response headers */
+    headers: Record<string, string>;
+}
+/**
+ * Island manifest entry for a single island
+ */
+export interface IslandEntry {
+    /** Compiled JavaScript path */
+    src: string;
+    /** Framework identifier (react, vue, svelte, etc.) */
+    framework: string;
+    /** CSS dependencies */
+    css?: string[];
+    /** Preload dependencies */
+    preload?: string[];
+}
+/**
+ * Island manifest for production builds
+ */
+export interface IslandManifest {
+    /** Map of island ID to compiled asset information */
+    islands: Record<string, IslandEntry>;
+    /** Client entry script path */
+    clientEntry: string;
+    /** CSS assets to inject */
+    css: string[];
+}
+/**
+ * Page module export interface
+ */
+export interface PageModule {
+    /** Default export - the page component */
+    default: unknown;
+    /** Optional page metadata */
+    metadata?: PageMetadata;
+    /** Optional getStaticProps for static generation */
+    getStaticProps?: () => Promise<Record<string, unknown>>;
+    /** Optional getServerSideProps for SSR */
+    getServerSideProps?: (context: NitroRenderContext) => Promise<Record<string, unknown>>;
+}
+/**
+ * Page metadata for SEO and configuration
+ */
+export interface PageMetadata {
+    /** Page title */
+    title?: string;
+    /** Page description */
+    description?: string;
+    /** Open Graph metadata */
+    openGraph?: {
+        title?: string;
+        description?: string;
+        image?: string;
+    };
+    /** Additional head elements */
+    head?: Array<{
+        tag: string;
+        attrs?: Record<string, string>;
+        content?: string;
+    }>;
+}
+/**
+ * Error response structure
+ */
+export interface ErrorResponse {
+    /** HTTP status code */
+    statusCode: number;
+    /** Error message */
+    message: string;
+    /** Stack trace (development only) */
+    stack?: string;
+    /** Additional error data */
+    data?: Record<string, unknown>;
+}
+/**
+ * HTTP error class for typed error handling
+ */
+export declare class HttpError extends Error {
+    /** HTTP status code */
+    statusCode: number;
+    /** Additional error data */
+    data?: Record<string, unknown>;
+    constructor(statusCode: number, message: string, data?: Record<string, unknown>);
+}
+/**
+ * Create a 404 Not Found error
+ */
+export declare function createNotFoundError(message?: string): HttpError;
+/**
+ * Create a 405 Method Not Allowed error
+ */
+export declare function createMethodNotAllowedError(allowedMethods: string[]): HttpError;
+/**
+ * Create a 500 Internal Server Error
+ */
+export declare function createInternalError(message?: string): HttpError;
+/**
+ * Type guard to check if an error is an HttpError
+ */
+export declare function isHttpError(error: unknown): error is HttpError;
+/**
+ * Avalon context stored in H3 event.context
+ */
+export interface AvalonEventContext {
+    /** Middleware context after middleware execution */
+    middlewareContext?: MiddlewareContext;
+    /** Resolved route information */
+    route?: NitroRouteConfig;
+    /** Page props from getServerSideProps */
+    pageProps?: Record<string, unknown>;
+}
+/**
+ * Development server options
+ */
+export interface DevServerOptions {
+    /** Port to listen on */
+    port?: number;
+    /** Host to bind to */
+    host?: string;
+    /** Enable HTTPS */
+    https?: boolean;
+    /** Open browser on start */
+    open?: boolean;
+}
+/**
+ * Build options for production
+ */
+export interface BuildOptions {
+    /** Output directory */
+    outDir?: string;
+    /** Enable source maps */
+    sourcemap?: boolean;
+    /** Minify output */
+    minify?: boolean;
+    /** Target preset */
+    preset?: string;
+}

package/dist/src/render/collect-css.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Collect CSS from Vite's module graph for SSR.
+ *
+ * After ssrLoadModule loads a page, Vite's module graph knows about all
+ * imported CSS files (including CSS modules). This utility walks the graph
+ * starting from the page module and collects all CSS content so it can be
+ * injected into the SSR HTML as <style> tags — preventing FOUC.
+ */
+import type { ViteDevServer } from "vite";
+/**
+ * Collect all CSS imported (directly or transitively) by a given module URL.
+ *
+ * Walks Vite's module graph breadth-first, collecting the transformed CSS
+ * source for every `.css` dependency (including `.module.css`).
+ *
+ * @param server - The Vite dev server instance
+ * @param moduleUrl - The module URL to start from (e.g. "/src/pages/frameworks.tsx")
+ * @returns Array of CSS strings ready to be injected as <style> tags
+ */
+export declare function collectCssFromModuleGraph(server: ViteDevServer, moduleUrl: string): Promise<string[]>;
+/**
+ * Inject collected CSS into an HTML string before </head>.
+ *
+ * Each CSS string is wrapped in a <style data-avalon-ssr-css> tag.
+ * CSS content is sanitized to prevent style tag breakout (XSS via </style> injection).
+ * If no </head> is found, styles are prepended to the HTML.
+ */
+export declare function injectSsrCss(html: string, cssContents: string[]): string;

package/dist/src/render/error-pages.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Shared error page HTML templates for development mode.
+ * Extracted from nitro-integration.ts to keep that file focused on coordination.
+ *
+ * @module render/error-pages
+ */
+/**
+ * Generates a styled 500 error page for development with stack trace.
+ */
+export declare function generateErrorPage(error: Error): string;
+/**
+ * Generates a minimal fallback 404 page when the error handler itself fails.
+ */
+export declare function generateFallback404(url: string): string;

package/dist/src/render/isolated-ssr-renderer.d.ts

@@ -0,0 +1,127 @@
+/**
+ * Isolated SSR Renderer
+ *
+ * This module provides framework-specific SSR contexts to prevent cross-contamination
+ * between different frameworks during server-side rendering. Each framework gets its
+ * own isolated import context and rendering pipeline.
+ */
+import type { JSX } from 'preact';
+export interface FrameworkSSRContext {
+    framework: string;
+    imports: Map<string, unknown>;
+    renderFunction: (component: unknown, props: unknown) => Promise<string>;
+    cleanup: () => void;
+    isActive: boolean;
+}
+export interface SSRIsolationConfig {
+    enableStrictIsolation: boolean;
+    allowedCrossFrameworkImports: string[];
+    errorHandling: 'strict' | 'fallback' | 'ignore';
+    debugLogging: boolean;
+}
+export interface IsolatedRenderRequest {
+    componentPath: string;
+    component: () => JSX.Element | Promise<JSX.Element>;
+    framework?: string;
+    props?: Record<string, unknown>;
+}
+export interface IsolatedRenderResult {
+    html: string;
+    framework: string;
+    success: boolean;
+    errors: string[];
+    warnings: string[];
+}
+/**
+ * Isolated SSR Renderer with framework-specific contexts
+ */
+export declare class IsolatedSSRRenderer {
+    private readonly contexts;
+    private readonly detector;
+    private config;
+    private activeContext;
+    constructor(config?: Partial<SSRIsolationConfig>);
+    /**
+     * Renders a component with framework isolation
+     */
+    renderWithIsolation(request: IsolatedRenderRequest): Promise<IsolatedRenderResult>;
+    private resolveFramework;
+    private renderInContext;
+    private tryFallbackRender;
+    /**
+     * Initializes framework-specific SSR contexts
+     */
+    private initializeFrameworkContexts;
+    /**
+     * Gets or creates a framework context
+     */
+    private getFrameworkContext;
+    /**
+     * Switches to a specific framework context with isolation
+     */
+    private switchToContext;
+    /**
+     * Cleans up a framework context
+     */
+    private cleanupContext;
+    /**
+     * Sets up framework-specific environment
+     */
+    private setupFrameworkEnvironment;
+    /**
+     * Imports a framework module with isolation
+     */
+    private importFrameworkModule;
+    /**
+     * Checks if an import is allowed for a specific framework
+     */
+    private isImportAllowed;
+    /**
+     * Clears framework-specific globals
+     */
+    private clearFrameworkGlobals;
+    /**
+     * Ensures Solid environment is properly set up
+     */
+    private ensureSolidEnvironment;
+    /**
+     * Ensures Vue environment is properly set up
+     */
+    private ensureVueEnvironment;
+    /**
+     * Ensures Svelte environment is properly set up
+     */
+    private ensureSvelteEnvironment;
+    /**
+     * Gets component content for framework detection
+     */
+    private getComponentContent;
+    /**
+     * Gets current active context
+     */
+    getActiveContext(): string | null;
+    /**
+     * Gets all framework contexts
+     */
+    getContexts(): Map<string, FrameworkSSRContext>;
+    /**
+     * Updates configuration
+     */
+    updateConfig(config: Partial<SSRIsolationConfig>): void;
+    /**
+     * Resets all contexts
+     */
+    resetAllContexts(): void;
+    /**
+     * Creates fallback rendering when framework modules are unavailable
+     */
+    renderWithFallback(component: () => JSX.Element | Promise<JSX.Element>, preferredFramework: string): Promise<IsolatedRenderResult>;
+    /**
+     * Validates that a framework context is properly set up
+     */
+    validateFrameworkContext(framework: string): Promise<boolean>;
+    /**
+     * Gets framework-specific error recovery strategies
+     */
+    getErrorRecoveryStrategies(framework: string): string[];
+}

package/dist/src/render/ssr.d.ts

@@ -0,0 +1,56 @@
+import { type JSX } from 'preact';
+import type { RenderOptions } from '../schemas/core.ts';
+import type { EnhancedLayoutResolver } from '../core/layout/enhanced-layout-resolver.ts';
+import type { LayoutContext } from '../types/layout.ts';
+export interface RouteConfig {
+    component: () => JSX.Element | Promise<JSX.Element>;
+    options?: Partial<RenderOptions>;
+    frontmatter?: Record<string, unknown>;
+}
+export interface RenderStrategy {
+    type: 'hydrate' | 'ssr-only';
+    reason: string;
+    warnings?: string[];
+}
+export interface ComponentRenderOptions {
+    forceSSROnly?: boolean;
+    detectScripts?: boolean;
+    suppressWarnings?: boolean;
+    logDecisions?: boolean;
+}
+export declare function renderToHtml(routeConfig: RouteConfig, defaultOptions?: Partial<RenderOptions>, viteHmrPort?: number, renderOptions?: ComponentRenderOptions): Promise<string>;
+/**
+ * Render to HTML with layout system support
+ */
+export declare function renderToHtmlWithLayouts(routeConfig: RouteConfig, layoutResolver: EnhancedLayoutResolver, layoutContext: LayoutContext, routePath: string, defaultOptions?: Partial<RenderOptions>, viteHmrPort?: number, renderOptions?: ComponentRenderOptions): Promise<string>;
+/**
+ * Streaming render options
+ */
+export interface StreamingRenderOptions extends ComponentRenderOptions {
+    /**
+     * Callback when the shell (initial HTML) is ready to stream
+     */
+    onShellReady?: () => void;
+    /**
+     * Callback when an error occurs before streaming starts
+     */
+    onShellError?: (error: Error) => void;
+    /**
+     * Callback when all content has been rendered
+     */
+    onAllReady?: () => void;
+    /**
+     * Callback for any error during rendering
+     */
+    onError?: (error: Error) => void;
+}
+/**
+ * Renders a route to a streaming HTML response
+ * This is the streaming equivalent of renderToHtml()
+ */
+export declare function renderToHtmlStream(routeConfig: RouteConfig, defaultOptions?: Partial<RenderOptions>, viteHmrPort?: number, renderOptions?: StreamingRenderOptions): Promise<ReadableStream<Uint8Array>>;
+/**
+ * Renders a route with layouts to a streaming HTML response
+ * This is the streaming equivalent of renderToHtmlWithLayouts()
+ */
+export declare function renderToHtmlStreamWithLayouts(routeConfig: RouteConfig, layoutResolver: EnhancedLayoutResolver, layoutContext: LayoutContext, routePath: string, defaultOptions?: Partial<RenderOptions>, viteHmrPort?: number, renderOptions?: StreamingRenderOptions): Promise<ReadableStream<Uint8Array>>;

package/dist/src/schemas/api.d.ts

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+/**
+ * Supported HTTP methods for API routes
+ */
+export declare const ApiMethodSchema: z.ZodEnum<{
+    GET: "GET";
+    POST: "POST";
+    PUT: "PUT";
+    DELETE: "DELETE";
+    PATCH: "PATCH";
+    HEAD: "HEAD";
+    OPTIONS: "OPTIONS";
+}>;
+export type ApiMethod = z.infer<typeof ApiMethodSchema>;
+/**
+ * Discovered API route with metadata
+ */
+export interface ApiRoute {
+    /** URL pattern for matching requests */
+    pattern: URLPattern;
+    /** Route configuration with handlers */
+    config: unknown;
+    /** Original file path relative to src/api */
+    filePath: string;
+    /** Extracted dynamic parameter names */
+    paramNames: string[];
+}

package/dist/src/schemas/core.d.ts

@@ -0,0 +1,75 @@
+import { z } from 'zod';
+/**
+ * Schema for meta tags
+ */
+export declare const MetaTagSchema: z.ZodObject<{
+    name: z.ZodString;
+    content: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Script configuration schema - supports both simple URLs and complex script objects
+ */
+export declare const ScriptConfigSchema: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+    src: z.ZodOptional<z.ZodString>;
+    content: z.ZodOptional<z.ZodString>;
+    data: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodArray<z.ZodUnknown>, z.ZodString]>>;
+    type: z.ZodOptional<z.ZodString>;
+    async: z.ZodOptional<z.ZodBoolean>;
+    defer: z.ZodOptional<z.ZodBoolean>;
+    crossorigin: z.ZodOptional<z.ZodEnum<{
+        anonymous: "anonymous";
+        "use-credentials": "use-credentials";
+    }>>;
+    integrity: z.ZodOptional<z.ZodString>;
+    nomodule: z.ZodOptional<z.ZodBoolean>;
+    referrerpolicy: z.ZodOptional<z.ZodEnum<{
+        "no-referrer": "no-referrer";
+        "no-referrer-when-downgrade": "no-referrer-when-downgrade";
+        origin: "origin";
+        "origin-when-cross-origin": "origin-when-cross-origin";
+        "same-origin": "same-origin";
+        "strict-origin": "strict-origin";
+        "strict-origin-when-cross-origin": "strict-origin-when-cross-origin";
+        "unsafe-url": "unsafe-url";
+    }>>;
+    attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>]>;
+/**
+ * Simplified render options for Vite-powered architecture
+ */
+export declare const RenderOptionsSchema: z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    scripts: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        src: z.ZodOptional<z.ZodString>;
+        content: z.ZodOptional<z.ZodString>;
+        data: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodArray<z.ZodUnknown>, z.ZodString]>>;
+        type: z.ZodOptional<z.ZodString>;
+        async: z.ZodOptional<z.ZodBoolean>;
+        defer: z.ZodOptional<z.ZodBoolean>;
+        crossorigin: z.ZodOptional<z.ZodEnum<{
+            anonymous: "anonymous";
+            "use-credentials": "use-credentials";
+        }>>;
+        integrity: z.ZodOptional<z.ZodString>;
+        nomodule: z.ZodOptional<z.ZodBoolean>;
+        referrerpolicy: z.ZodOptional<z.ZodEnum<{
+            "no-referrer": "no-referrer";
+            "no-referrer-when-downgrade": "no-referrer-when-downgrade";
+            origin: "origin";
+            "origin-when-cross-origin": "origin-when-cross-origin";
+            "same-origin": "same-origin";
+            "strict-origin": "strict-origin";
+            "strict-origin-when-cross-origin": "strict-origin-when-cross-origin";
+            "unsafe-url": "unsafe-url";
+        }>>;
+        attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strip>]>>>;
+    styles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    meta: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        content: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type MetaTag = z.infer<typeof MetaTagSchema>;
+export type ScriptConfig = z.infer<typeof ScriptConfigSchema>;
+export type RenderOptions = z.infer<typeof RenderOptionsSchema>;

package/dist/src/schemas/index.d.ts

@@ -0,0 +1,79 @@
+import { z } from 'zod';
+import type { RenderOptions } from './core.ts';
+import type { LayoutContext, LayoutData, LayoutHandler, LayoutDiscoveryOptions, LayoutConfig, ResolvedLayout } from './layout.ts';
+import type { FileSystemRoute, RoutePageModule, RouteDiscoveryOptions, FileSystemRouterConfig, Metadata, ResolvedMetadata } from './routing.ts';
+export * from './core.ts';
+export * from './api.ts';
+export * from './layout.ts';
+export * from './routing.ts';
+export interface ValidationSuccess<T> {
+    success: true;
+    data: T;
+}
+export interface ValidationFailure {
+    success: false;
+    error: ValidationError;
+}
+export type ValidationResult<T> = ValidationSuccess<T> | ValidationFailure;
+export declare class ValidationError extends Error {
+    readonly zodError: z.ZodError;
+    constructor(message: string, zodError: z.ZodError);
+    getFormattedErrors(): string[];
+    getErrorMessage(): string;
+}
+export declare function createValidationError(message: string, zodError: z.ZodError): ValidationError;
+export declare function safeValidate<TOutput>(schema: z.ZodType<TOutput>, data: unknown, errorMessage?: string): ValidationResult<TOutput>;
+export declare function validate<TOutput>(schema: z.ZodType<TOutput>, data: unknown, errorMessage?: string): TOutput;
+export declare const validators: {
+    readonly renderOptions: (data: unknown) => RenderOptions;
+    readonly layoutContext: (data: unknown) => LayoutContext;
+    readonly layoutData: (data: unknown) => LayoutData;
+    readonly layoutHandler: (data: unknown) => LayoutHandler;
+    readonly layoutDiscoveryOptions: (data: unknown) => LayoutDiscoveryOptions;
+    readonly layoutConfig: (data: unknown) => LayoutConfig;
+    readonly resolvedLayout: (data: unknown) => ResolvedLayout;
+    readonly fileSystemRoute: (data: unknown) => FileSystemRoute;
+    readonly routePageModule: (data: unknown) => RoutePageModule;
+    readonly routeDiscoveryOptions: (data: unknown) => RouteDiscoveryOptions;
+    readonly fileSystemRouterConfig: (data: unknown) => FileSystemRouterConfig;
+    readonly metadata: (data: unknown) => Metadata;
+    readonly resolvedMetadata: (data: unknown) => ResolvedMetadata;
+};
+export declare const safeValidators: {
+    readonly renderOptions: (data: unknown) => ValidationResult<RenderOptions>;
+    readonly layoutContext: (data: unknown) => ValidationResult<LayoutContext>;
+    readonly layoutData: (data: unknown) => ValidationResult<LayoutData>;
+    readonly layoutHandler: (data: unknown) => ValidationResult<LayoutHandler>;
+    readonly layoutDiscoveryOptions: (data: unknown) => ValidationResult<LayoutDiscoveryOptions>;
+    readonly layoutConfig: (data: unknown) => ValidationResult<LayoutConfig>;
+    readonly resolvedLayout: (data: unknown) => ValidationResult<ResolvedLayout>;
+    readonly fileSystemRoute: (data: unknown) => ValidationResult<FileSystemRoute>;
+    readonly routePageModule: (data: unknown) => ValidationResult<RoutePageModule>;
+    readonly routeDiscoveryOptions: (data: unknown) => ValidationResult<RouteDiscoveryOptions>;
+    readonly fileSystemRouterConfig: (data: unknown) => ValidationResult<FileSystemRouterConfig>;
+    readonly metadata: (data: unknown) => ValidationResult<Metadata>;
+    readonly resolvedMetadata: (data: unknown) => ValidationResult<ResolvedMetadata>;
+};
+export declare const devValidators: {
+    readonly renderOptionsSoft: (data: unknown, context?: string) => boolean;
+};
+export declare function isValidRenderOptions(data: unknown): data is RenderOptions;
+export declare function isValidFileSystemRoute(data: unknown): data is FileSystemRoute;
+export declare function isValidRoutePageModule(data: unknown): data is RoutePageModule;
+export declare function isValidRouteDiscoveryOptions(data: unknown): data is RouteDiscoveryOptions;
+export declare function isValidFileSystemRouterConfig(data: unknown): data is FileSystemRouterConfig;
+export declare function isValidMetadata(data: unknown): data is Metadata;
+export declare function isValidResolvedMetadata(data: unknown): data is ResolvedMetadata;
+export declare function validateBatch<T extends Record<string, unknown>>(schemas: {
+    [K in keyof T]: z.ZodType<T[K]>;
+}, data: {
+    [K in keyof T]: unknown;
+}): T;
+export declare function safeValidateBatch<T extends Record<string, unknown>>(schemas: {
+    [K in keyof T]: z.ZodType<T[K]>;
+}, data: {
+    [K in keyof T]: unknown;
+}): ValidationResult<T>;
+export type ExtractValidationData<T> = T extends ValidationResult<infer U> ? U : never;
+export type ExtractSchemaInput<T> = T extends z.ZodType<infer U> ? U : never;
+export type ExtractSchemaOutput<T> = T extends z.ZodType<infer U> ? U : never;