@flexireact/core 4.0.0 → 4.1.1

package/dist/core/index.d.ts

@@ -0,0 +1,1978 @@
+import React, { ReactNode } from 'react';
+export { useActionState, useOptimistic } from 'react';
+export { defaultConfig, loadConfig, resolvePaths } from './config.js';
+import * as http from 'http';
+import createServer from './server/index.js';
+export { BuildMode, build, buildDev } from './build/index.js';
+export { useFormStatus } from 'react-dom';
+import 'zod';
+import 'esbuild';
+
+/**
+ * FlexiReact Core Types
+ */
+
+interface FlexiConfig {
+    /** Stylesheets to include */
+    styles?: string[];
+    /** Favicon path */
+    favicon?: string;
+    /** Server configuration */
+    server?: {
+        port?: number;
+        host?: string;
+    };
+    /** Islands configuration */
+    islands?: {
+        enabled?: boolean;
+    };
+    /** Routing configuration */
+    routing?: {
+        type?: 'flexi' | 'app' | 'pages';
+    };
+    /** Pages directory */
+    pagesDir?: string;
+    /** Layouts directory */
+    layoutsDir?: string;
+    /** Public directory */
+    publicDir?: string;
+}
+type RouteType$1 = 'page' | 'api' | 'layout' | 'loading' | 'error' | 'not-found';
+interface Route {
+    type: RouteType$1;
+    path: string;
+    filePath: string;
+    pattern: RegExp;
+    segments: string[];
+    layout?: string | null;
+    loading?: string | null;
+    error?: string | null;
+    notFound?: string | null;
+    template?: string | null;
+    isAppRouter?: boolean;
+    isFlexiRouter?: boolean;
+    isServerComponent?: boolean;
+    isClientComponent?: boolean;
+    isIsland?: boolean;
+    params?: Record<string, string>;
+}
+interface PageProps {
+    params?: Record<string, string>;
+    searchParams?: Record<string, string>;
+}
+interface LayoutProps {
+    children: ReactNode;
+    params?: Record<string, string>;
+}
+
+/**
+ * Creates a request context value
+ */
+declare function createRequestContext(req: http.IncomingMessage, res: http.ServerResponse, params?: Record<string, string>, query?: Record<string, string>): {
+    req: http.IncomingMessage;
+    res: http.ServerResponse<http.IncomingMessage>;
+    params: Record<string, string>;
+    query: Record<string, string>;
+    url: string | undefined;
+    method: string | undefined;
+    headers: http.IncomingHttpHeaders;
+    cookies: Record<string, string>;
+};
+/**
+ * Hook to access request context (server-side only)
+ */
+declare function useRequest(): any;
+/**
+ * Hook to access route params
+ */
+declare function useParams(): Record<string, string>;
+/**
+ * Hook to access query parameters
+ */
+declare function useQuery(): Record<string, string>;
+/**
+ * Hook to access current pathname
+ */
+declare function usePathname(): string;
+
+/**
+ * FlexiReact Utility Functions
+ */
+/**
+ * Generates a unique hash for cache busting
+ */
+declare function generateHash(content: string): string;
+/**
+ * Escapes HTML special characters
+ */
+declare function escapeHtml(str: string): string;
+/**
+ * Recursively finds all files matching a pattern
+ */
+declare function findFiles(dir: string, pattern: RegExp, files?: string[]): string[];
+/**
+ * Ensures a directory exists
+ */
+declare function ensureDir(dir: string): void;
+/**
+ * Cleans a directory
+ */
+declare function cleanDir(dir: string): void;
+/**
+ * Copies a directory recursively
+ */
+declare function copyDir(src: string, dest: string): void;
+/**
+ * Debounce function for file watching
+ */
+declare function debounce<T extends (...args: any[]) => any>(fn: T, delay: number): (...args: Parameters<T>) => void;
+/**
+ * Formats bytes to human readable string
+ */
+declare function formatBytes(bytes: number): string;
+/**
+ * Formats milliseconds to human readable string
+ */
+declare function formatTime(ms: number): string;
+/**
+ * Creates a deferred promise
+ */
+declare function createDeferred(): {
+    promise: Promise<unknown>;
+    resolve: any;
+    reject: any;
+};
+/**
+ * Sleep utility
+ */
+declare function sleep(ms: number): Promise<void>;
+/**
+ * Check if a file is a server component (has 'use server' directive)
+ */
+declare function isServerComponent(filePath: string): boolean;
+/**
+ * Check if a file is a client component (has 'use client' directive)
+ */
+declare function isClientComponent(filePath: string): boolean;
+/**
+ * Check if a component is an island (has 'use island' directive)
+ */
+declare function isIsland(filePath: string): boolean;
+
+/**
+ * FlexiReact Router v2
+ * Advanced file-based routing with nested routes, loading, and error boundaries
+ *
+ * Supports multiple routing conventions:
+ * - pages/     : Traditional file-based routing (index.tsx, about.tsx)
+ * - app/       : Next.js style App Router (page.tsx, layout.tsx)
+ * - routes/    : FlexiReact v4 routes directory (home.tsx → /, [slug].tsx → /:slug)
+ */
+/**
+ * Route types
+ */
+declare const RouteType: {
+    PAGE: string;
+    API: string;
+    LAYOUT: string;
+    LOADING: string;
+    ERROR: string;
+    NOT_FOUND: string;
+};
+/**
+ * Builds the complete route tree from all routing directories
+ */
+declare function buildRouteTree(pagesDir: string, layoutsDir: string, appDir?: string | null, routesDir?: string | null): {
+    pages: any[];
+    api: any[];
+    layouts: Map<any, any>;
+    tree: Record<string, any>;
+    appRoutes: any[];
+    flexiRoutes: any[];
+    rootLayout?: string;
+};
+/**
+ * Matches URL path against routes
+ */
+declare function matchRoute(urlPath: string, routes: any[]): any;
+/**
+ * Finds all layouts that apply to a route
+ */
+declare function findRouteLayouts(route: any, layoutsMap: Map<string, string>): Array<{
+    name: string;
+    filePath: string | undefined;
+}>;
+
+/**
+ * FlexiReact Render System v2
+ * SSR with layouts, loading states, error boundaries, and islands
+ */
+
+/**
+ * Renders a page with all its layouts and wrappers
+ */
+declare function renderPage(options: any): Promise<string>;
+/**
+ * Streaming SSR with React 18
+ * Renders the page progressively, sending HTML chunks as they become ready
+ */
+declare function renderPageStream(options: {
+    Component: React.ComponentType<any>;
+    props?: Record<string, any>;
+    layouts?: Array<{
+        Component: React.ComponentType<any>;
+        props?: Record<string, any>;
+    }>;
+    loading?: React.ComponentType | null;
+    error?: React.ComponentType<{
+        error: Error;
+    }> | null;
+    title?: string;
+    meta?: Record<string, string>;
+    scripts?: Array<string | {
+        src?: string;
+        content?: string;
+        type?: string;
+    }>;
+    styles?: Array<string | {
+        content: string;
+    }>;
+    favicon?: string | null;
+    route?: string;
+    onShellReady?: () => void;
+    onAllReady?: () => void;
+    onError?: (error: Error) => void;
+}): Promise<{
+    stream: NodeJS.ReadableStream;
+    shellReady: Promise<void>;
+}>;
+/**
+ * Render to stream for HTTP response
+ * Use this in the server to stream HTML to the client
+ */
+declare function streamToResponse(res: {
+    write: (chunk: string) => void;
+    end: () => void;
+}, stream: NodeJS.ReadableStream, options?: {
+    onFinish?: () => void;
+}): void;
+/**
+ * Renders an error page with beautiful styling (FlexiReact v4)
+ */
+declare function renderError(statusCode: number, message: string, stack?: string | null): string;
+/**
+ * Renders a loading state
+ */
+declare function renderLoading(LoadingComponent: React.ComponentType | null): string;
+
+/**
+ * FlexiReact Static Site Generation (SSG)
+ *
+ * SSG pre-renders pages at build time, generating static HTML files.
+ * This provides the fastest possible page loads and enables CDN caching.
+ *
+ * Usage:
+ * - Export getStaticProps() from a page to fetch data at build time
+ * - Export getStaticPaths() for dynamic routes to specify which paths to pre-render
+ * - Pages without these exports are rendered as static HTML
+ */
+/**
+ * SSG Build Result
+ */
+interface SSGPage {
+    path: string;
+    file: string;
+    size: number;
+}
+interface SSGError {
+    path: string;
+    error: string;
+}
+declare class SSGResult {
+    pages: SSGPage[];
+    errors: SSGError[];
+    duration: number;
+    constructor();
+    addPage(pagePath: string, file: string, size: number): void;
+    addError(pagePath: string, error: Error): void;
+    get success(): boolean;
+    get totalSize(): number;
+}
+/**
+ * Generates static pages for all routes
+ */
+declare function generateStaticSite(options: any): Promise<SSGResult>;
+/**
+ * Incremental Static Regeneration (ISR) support
+ * Allows pages to be regenerated after a specified interval
+ */
+interface ISRCacheEntry {
+    html: string;
+    generatedAt: number;
+    revalidateAfter: number | null;
+}
+declare class ISRManager {
+    cache: Map<string, ISRCacheEntry>;
+    revalidating: Set<string>;
+    defaultRevalidate: number;
+    constructor(options?: {
+        defaultRevalidate?: number;
+    });
+    /**
+     * Gets a cached page or regenerates it
+     */
+    getPage(routePath: string, generator: () => Promise<{
+        html: string;
+        revalidate?: number;
+    }>): Promise<string>;
+    /**
+     * Revalidates a page in the background
+     */
+    revalidateInBackground(routePath: string, generator: () => Promise<{
+        html: string;
+        revalidate?: number;
+    }>): Promise<void>;
+    /**
+     * Invalidates a cached page
+     */
+    invalidate(routePath: string): void;
+    /**
+     * Clears all cached pages
+     */
+    clear(): void;
+}
+
+/**
+ * FlexiReact React Server Components (RSC) System
+ *
+ * RSC allows components to run exclusively on the server, reducing client bundle size
+ * and enabling direct database/filesystem access in components.
+ *
+ * Usage:
+ * - Add 'use server' at the top of a component file to make it a Server Component
+ * - Add 'use client' at the top to make it a Client Component (hydrated on client)
+ * - Server Components can import Client Components, but not vice versa
+ */
+
+/**
+ * RSC Payload format for streaming
+ */
+declare const RSC_CONTENT_TYPE = "text/x-component";
+/**
+ * Processes a component tree for RSC
+ * Server components are rendered to HTML, client components are serialized
+ */
+declare function processServerComponent(Component: any, props: any, context: any): Promise<{
+    isServer: boolean;
+    rendered: string | null;
+    clientComponents: any[];
+    serverData: Record<string, any>;
+}>;
+/**
+ * Creates a client component reference for RSC payload
+ */
+declare function createClientReference(componentPath: string, props: any): {
+    $$typeof: symbol;
+    $$id: string;
+    $$props: any;
+};
+/**
+ * Serializes RSC payload for streaming
+ */
+declare function serializeRSCPayload(componentTree: any): string;
+/**
+ * Server Actions support
+ * Allows calling server functions from client components
+ */
+declare function createServerAction(fn: any, actionId: string): any;
+/**
+ * Handles server action invocation
+ */
+declare function handleServerAction(actionId: string, args: any[], context: any): Promise<any>;
+/**
+ * RSC Boundary component
+ * Marks the boundary between server and client rendering
+ */
+declare function ServerBoundary({ children, fallback }: {
+    children: React.ReactNode;
+    fallback?: React.ReactNode;
+}): React.ReactNode;
+/**
+ * Client Boundary component
+ * Marks components that should be hydrated on the client
+ */
+declare function ClientBoundary({ children, fallback }: {
+    children: React.ReactNode;
+    fallback?: React.ReactNode;
+}): React.DetailedReactHTMLElement<{
+    'data-flexi-client': string;
+    children: React.ReactNode;
+}, HTMLElement>;
+
+/**
+ * FlexiReact Islands Architecture
+ *
+ * Islands allow partial hydration - only interactive components are hydrated on the client,
+ * while static content remains as HTML. This dramatically reduces JavaScript bundle size.
+ *
+ * Usage:
+ * - Add 'use island' at the top of a component file
+ * - The component will be rendered on server and hydrated on client
+ * - Non-island components are pure HTML (no JS)
+ */
+
+/**
+ * Island wrapper component for server-side rendering
+ * Islands render a placeholder on the server and hydrate on the client
+ */
+declare function Island({ component: Component, props, name, clientPath }: {
+    component: React.ComponentType<any>;
+    props?: any;
+    name: string;
+    clientPath: string;
+}): React.DetailedReactHTMLElement<{
+    'data-island': string;
+    'data-island-name': string;
+    'data-island-props': string;
+    dangerouslySetInnerHTML: {
+        __html: string;
+    };
+}, HTMLElement>;
+/**
+ * Gets all registered islands and clears the registry
+ */
+declare function getRegisteredIslands(): any[];
+/**
+ * Creates an island component wrapper
+ */
+interface IslandOptions {
+    name?: string;
+    clientPath?: string;
+}
+declare function createIsland(Component: React.ComponentType<any>, options?: IslandOptions): {
+    (props: any): React.DetailedReactHTMLElement<{
+        'data-island': string;
+        'data-island-name': string;
+        'data-island-props': string;
+        dangerouslySetInnerHTML: {
+            __html: string;
+        };
+    }, HTMLElement>;
+    displayName: string;
+    isIsland: boolean;
+    originalComponent: React.ComponentType<any>;
+};
+/**
+ * Generates the client-side hydration script
+ */
+declare function generateHydrationScript(islands: any[]): string;
+/**
+ * Island loading strategies
+ */
+declare const LoadStrategy: {
+    IMMEDIATE: string;
+    VISIBLE: string;
+    IDLE: string;
+    MEDIA: string;
+};
+/**
+ * Creates a lazy island that hydrates based on strategy
+ */
+interface LazyIslandOptions {
+    name?: string;
+    clientPath?: string;
+    strategy?: string;
+    media?: string | null;
+}
+declare function createLazyIsland(Component: React.ComponentType<any>, options?: LazyIslandOptions): {
+    (props: any): React.DetailedReactHTMLElement<{
+        'data-island': string;
+        'data-island-name': any;
+        'data-island-strategy': string;
+        'data-island-media': string | null;
+        'data-island-props': string;
+        dangerouslySetInnerHTML: {
+            __html: string;
+        };
+    }, HTMLElement>;
+    displayName: string;
+    isIsland: boolean;
+    isLazy: boolean;
+};
+/**
+ * Generates advanced hydration script with loading strategies
+ */
+declare function generateAdvancedHydrationScript(islands: any[]): string;
+
+/**
+ * FlexiReact Middleware System
+ *
+ * Middlewares run before every request and can:
+ * - Modify the request/response
+ * - Redirect or rewrite URLs
+ * - Add headers
+ * - Authenticate users
+ * - Log requests
+ *
+ * Usage:
+ * Create a middleware.js file in your project root:
+ *
+ * export default function middleware(request) {
+ *   // Return a response to short-circuit
+ *   // Return NextResponse.next() to continue
+ *   // Return NextResponse.redirect() to redirect
+ * }
+ *
+ * export const config = {
+ *   matcher: ['/protected/:path*']
+ * };
+ */
+/**
+ * Middleware response helpers
+ */
+interface MiddlewareResponseOptions {
+    type?: string;
+    status?: number;
+    headers?: Record<string, string>;
+    body?: any;
+    url?: string | null;
+}
+declare class MiddlewareResponse {
+    type: string;
+    status: number;
+    headers: Map<string, string>;
+    body: any;
+    url: string | null;
+    constructor(options?: MiddlewareResponseOptions);
+    /**
+     * Continue to the next middleware/handler
+     */
+    static next(options?: {}): MiddlewareResponse;
+    /**
+     * Redirect to a different URL
+     */
+    static redirect(url: string, status?: number): MiddlewareResponse;
+    /**
+     * Rewrite the request to a different URL (internal)
+     */
+    static rewrite(url: string): MiddlewareResponse;
+    /**
+     * Return a JSON response
+     */
+    static json(data: any, options?: {
+        status?: number;
+        headers?: Record<string, string>;
+    }): MiddlewareResponse;
+    /**
+     * Return an HTML response
+     */
+    static html(content: string, options?: {
+        status?: number;
+        headers?: Record<string, string>;
+    }): MiddlewareResponse;
+}
+/**
+ * Middleware request wrapper
+ */
+declare class MiddlewareRequest {
+    raw: any;
+    method: string;
+    url: string;
+    headers: Map<string, string>;
+    pathname: string;
+    searchParams: URLSearchParams;
+    query: Record<string, string>;
+    cookies: Map<string, string>;
+    constructor(req: any);
+    _parseCookies(cookieHeader: string): Map<string, string>;
+    /**
+     * Get a header value
+     */
+    header(name: string): string | undefined;
+    /**
+     * Get a cookie value
+     */
+    cookie(name: string): string | undefined;
+    /**
+     * Check if request matches a path pattern
+     */
+    matches(pattern: string): boolean;
+}
+/**
+ * Loads middleware from project
+ */
+declare function loadMiddleware(projectRoot: string): Promise<{
+    handler: any;
+    config: any;
+} | null>;
+/**
+ * Runs middleware chain
+ */
+declare function runMiddleware(req: any, res: any, middleware: any): Promise<{
+    continue: boolean;
+    rewritten?: undefined;
+    error?: undefined;
+} | {
+    continue: boolean;
+    rewritten: boolean;
+    error?: undefined;
+} | {
+    continue: boolean;
+    error: unknown;
+    rewritten?: undefined;
+}>;
+/**
+ * Compose multiple middleware functions
+ */
+declare function composeMiddleware(...middlewares: Array<(request: MiddlewareRequest) => Promise<MiddlewareResponse | null>>): (request: MiddlewareRequest) => Promise<MiddlewareResponse>;
+/**
+ * Built-in middleware helpers
+ */
+declare const middlewares: {
+    /**
+     * CORS middleware
+     */
+    cors(options?: {
+        origin?: string;
+        methods?: string;
+        headers?: string;
+        credentials?: boolean;
+    }): (request: MiddlewareRequest) => MiddlewareResponse;
+    /**
+     * Basic auth middleware
+     */
+    basicAuth(options: {
+        username: string;
+        password: string;
+        realm?: string;
+    }): (request: MiddlewareRequest) => MiddlewareResponse;
+    /**
+     * Rate limiting middleware
+     */
+    rateLimit(options?: {
+        windowMs?: number;
+        max?: number;
+    }): (request: MiddlewareRequest) => MiddlewareResponse;
+    /**
+     * Logging middleware
+     */
+    logger(options?: {
+        format?: string;
+    }): (request: MiddlewareRequest) => MiddlewareResponse;
+};
+
+/**
+ * FlexiReact Plugin System
+ *
+ * Plugins can extend FlexiReact's functionality by hooking into various lifecycle events.
+ *
+ * Usage:
+ * Create a flexireact.plugin.js file:
+ *
+ * export default {
+ *   name: 'my-plugin',
+ *
+ *   // Called when the server starts
+ *   onServerStart(server) {},
+ *
+ *   // Called before each request
+ *   onRequest(req, res) {},
+ *
+ *   // Called before rendering a page
+ *   onBeforeRender(page, props) {},
+ *
+ *   // Called after rendering a page
+ *   onAfterRender(html, page) {},
+ *
+ *   // Called during build
+ *   onBuild(config) {},
+ *
+ *   // Modify esbuild config
+ *   esbuildConfig(config) {},
+ * };
+ */
+/**
+ * Plugin lifecycle hooks
+ */
+declare const PluginHooks: {
+    SERVER_START: string;
+    SERVER_STOP: string;
+    REQUEST: string;
+    RESPONSE: string;
+    BEFORE_RENDER: string;
+    AFTER_RENDER: string;
+    BUILD_START: string;
+    BUILD_END: string;
+    ROUTES_LOADED: string;
+    CONFIG: string;
+    ESBUILD_CONFIG: string;
+};
+/**
+ * Plugin manager class
+ */
+declare class PluginManager {
+    plugins: any[];
+    hooks: Map<string, any[]>;
+    constructor();
+    /**
+     * Registers a plugin
+     */
+    register(plugin: any): void;
+    /**
+     * Unregisters a plugin
+     */
+    unregister(pluginName: any): void;
+    /**
+     * Runs a hook with all registered handlers
+     */
+    runHook(hookName: string, ...args: unknown[]): Promise<Array<{
+        plugin: string;
+        result?: unknown;
+        error?: unknown;
+    }>>;
+    /**
+     * Runs a hook that can modify a value (waterfall)
+     */
+    runWaterfallHook(hookName: any, initialValue: any, ...args: any[]): Promise<any>;
+    /**
+     * Checks if any plugin handles a hook
+     */
+    hasHook(hookName: any): boolean;
+    /**
+     * Gets all registered plugins
+     */
+    getPlugins(): any[];
+}
+declare const pluginManager: PluginManager;
+/**
+ * Loads plugins from project and config
+ */
+declare function loadPlugins(projectRoot: any, config: any): Promise<PluginManager>;
+/**
+ * Creates a plugin
+ */
+declare function definePlugin(options: any): any;
+/**
+ * Built-in plugins
+ */
+declare const builtinPlugins: {
+    /**
+     * Analytics plugin
+     */
+    analytics(options?: {
+        trackingId?: string;
+    }): any;
+    /**
+     * PWA plugin
+     */
+    pwa(options?: {
+        manifest?: string;
+        serviceWorker?: string;
+    }): any;
+    /**
+     * SEO plugin
+     */
+    seo(options?: {
+        defaultTitle?: string;
+        titleTemplate?: string;
+        defaultDescription?: string;
+    }): any;
+    /**
+     * Compression plugin (for production)
+     */
+    compression(): any;
+    /**
+     * Security headers plugin
+     */
+    securityHeaders(options?: {
+        headers?: Record<string, string>;
+    }): any;
+};
+
+/**
+ * FlexiReact Universal Edge Runtime
+ *
+ * Works on:
+ * - Node.js
+ * - Bun
+ * - Deno
+ * - Cloudflare Workers
+ * - Vercel Edge
+ * - Any Web-standard runtime
+ */
+type RuntimeEnvironment = 'node' | 'bun' | 'deno' | 'cloudflare' | 'vercel-edge' | 'netlify-edge' | 'fastly' | 'unknown';
+declare function detectRuntime(): RuntimeEnvironment;
+interface RuntimeCapabilities {
+    hasFileSystem: boolean;
+    hasWebCrypto: boolean;
+    hasWebStreams: boolean;
+    hasFetch: boolean;
+    hasWebSocket: boolean;
+    hasKV: boolean;
+    hasCache: boolean;
+    maxExecutionTime: number;
+    maxMemory: number;
+}
+declare function getRuntimeCapabilities(): RuntimeCapabilities;
+declare const runtime: {
+    name: RuntimeEnvironment;
+    capabilities: RuntimeCapabilities;
+    readonly isEdge: boolean;
+    readonly isServer: boolean;
+    readonly supportsStreaming: boolean;
+};
+
+/**
+ * Fetch API Polyfill for Universal Compatibility
+ *
+ * Ensures Request, Response, Headers work everywhere
+ */
+declare const GlobalRequest: {
+    new (input: RequestInfo | URL, init?: RequestInit): Request;
+    prototype: Request;
+};
+declare const GlobalResponse: {
+    new (body?: BodyInit | null, init?: ResponseInit): Response;
+    prototype: Response;
+    error(): Response;
+    json(data: any, init?: ResponseInit): Response;
+    redirect(url: string | URL, status?: number): Response;
+};
+declare const GlobalHeaders: {
+    new (init?: HeadersInit): Headers;
+    prototype: Headers;
+};
+declare class FlexiRequest extends GlobalRequest {
+    private _parsedUrl?;
+    private _cookies?;
+    constructor(input: RequestInfo | URL, init?: RequestInit);
+    get pathname(): string;
+    get searchParams(): URLSearchParams;
+    get cookies(): Map<string, string>;
+    cookie(name: string): string | undefined;
+    jsonBody<T = any>(): Promise<T>;
+    formBody(): Promise<FormData>;
+    query(name: string): string | null;
+    queryAll(name: string): string[];
+}
+declare class FlexiResponse extends GlobalResponse {
+    static json(data: any, init?: ResponseInit): FlexiResponse;
+    static html(html: string, init?: ResponseInit): FlexiResponse;
+    static text(text: string, init?: ResponseInit): FlexiResponse;
+    static redirect(url: string, status?: 301 | 302 | 303 | 307 | 308): FlexiResponse;
+    static notFound(message?: string): FlexiResponse;
+    static error(message?: string, status?: number): FlexiResponse;
+    static stream(stream: ReadableStream, init?: ResponseInit): FlexiResponse;
+    withCookie(name: string, value: string, options?: {
+        maxAge?: number;
+        expires?: Date;
+        path?: string;
+        domain?: string;
+        secure?: boolean;
+        httpOnly?: boolean;
+        sameSite?: 'Strict' | 'Lax' | 'None';
+    }): FlexiResponse;
+    withHeaders(newHeaders: Record<string, string>): FlexiResponse;
+}
+declare class FlexiHeaders extends GlobalHeaders {
+    getBearerToken(): string | null;
+    getBasicAuth(): {
+        username: string;
+        password: string;
+    } | null;
+    isJson(): boolean;
+    isFormData(): boolean;
+    isHtml(): boolean;
+}
+
+/**
+ * FlexiReact Universal Cache System
+ *
+ * Smart caching that works on:
+ * - Cloudflare Workers (Cache API + KV)
+ * - Vercel Edge (Edge Config + KV)
+ * - Deno (Deno KV)
+ * - Node.js/Bun (In-memory + File cache)
+ */
+interface CacheEntry<T = any> {
+    value: T;
+    expires: number;
+    stale?: number;
+    tags?: string[];
+    etag?: string;
+}
+interface CacheOptions {
+    ttl?: number;
+    staleWhileRevalidate?: number;
+    tags?: string[];
+    key?: string;
+    revalidate?: number | false;
+}
+declare function initCache(options?: {
+    kv?: any;
+}): void;
+declare function cacheFunction<T extends (...args: any[]) => Promise<any>>(fn: T, options?: CacheOptions): T;
+declare function unstable_cache<T extends (...args: any[]) => Promise<any>>(fn: T, keyParts?: string[], options?: {
+    revalidate?: number | false;
+    tags?: string[];
+}): T;
+declare function revalidateTag(tag: string): Promise<void>;
+declare function revalidatePath(path: string): Promise<void>;
+declare const cache: {
+    get: <T>(key: string) => Promise<CacheEntry<T> | null>;
+    set: <T>(key: string, value: T, options?: CacheOptions) => Promise<void>;
+    delete: (key: string) => Promise<void>;
+    deleteByTag: (tag: string) => Promise<void>;
+    clear: () => Promise<void>;
+    wrap: typeof cacheFunction;
+    unstable_cache: typeof unstable_cache;
+    revalidateTag: typeof revalidateTag;
+    revalidatePath: typeof revalidatePath;
+};
+declare function reactCache<T extends (...args: any[]) => any>(fn: T): T;
+
+/**
+ * FlexiReact Universal Edge Handler
+ *
+ * Single handler that works on all platforms:
+ * - Node.js (http.createServer)
+ * - Bun (Bun.serve)
+ * - Deno (Deno.serve)
+ * - Cloudflare Workers (fetch handler)
+ * - Vercel Edge (edge function)
+ */
+
+interface EdgeContext {
+    runtime: typeof runtime;
+    cache: typeof cache;
+    env: Record<string, string | undefined>;
+    waitUntil: (promise: Promise<any>) => void;
+    passThroughOnException?: () => void;
+}
+type EdgeHandler = (request: FlexiRequest, context: EdgeContext) => Promise<FlexiResponse> | FlexiResponse;
+type EdgeMiddleware = (request: FlexiRequest, context: EdgeContext, next: () => Promise<FlexiResponse>) => Promise<FlexiResponse> | FlexiResponse;
+interface EdgeAppConfig {
+    routes?: Map<string, EdgeHandler>;
+    middleware?: EdgeMiddleware[];
+    notFound?: EdgeHandler;
+    onError?: (error: Error, request: FlexiRequest) => FlexiResponse;
+    basePath?: string;
+}
+declare function createEdgeApp(config?: EdgeAppConfig): {
+    fetch: (request: Request, env?: Record<string, any>, executionContext?: {
+        waitUntil: (p: Promise<any>) => void;
+        passThroughOnException?: () => void;
+    }) => Promise<Response>;
+    scheduled(event: any, env: any, ctx: any): Promise<void>;
+    route(path: string, handler: EdgeHandler): /*elided*/ any;
+    use(mw: EdgeMiddleware): /*elided*/ any;
+    toNodeHandler(): (req: any, res: any) => Promise<void>;
+    toBunHandler(): {
+        fetch: (request: Request, env?: Record<string, any>, executionContext?: {
+            waitUntil: (p: Promise<any>) => void;
+            passThroughOnException?: () => void;
+        }) => Promise<Response>;
+        port: number;
+    };
+    toDenoHandler(): (request: Request, env?: Record<string, any>, executionContext?: {
+        waitUntil: (p: Promise<any>) => void;
+        passThroughOnException?: () => void;
+    }) => Promise<Response>;
+    listen(port?: number): Promise<any>;
+};
+
+/**
+ * FlexiReact Partial Prerendering (PPR)
+ *
+ * Combines static shell with dynamic content:
+ * - Static parts are prerendered at build time
+ * - Dynamic parts stream in at request time
+ * - Best of both SSG and SSR
+ */
+
+interface PPRConfig {
+    shellCacheTTL?: number;
+    dynamicTimeout?: number;
+    fallback?: React.ReactNode;
+}
+declare function dynamic<T extends React.ComponentType<any>>(Component: T, options?: {
+    fallback?: React.ReactNode;
+}): T;
+declare function staticComponent<T extends React.ComponentType<any>>(Component: T): T;
+interface SuspenseBoundaryProps {
+    children: React.ReactNode;
+    fallback?: React.ReactNode;
+    id?: string;
+}
+declare function PPRBoundary({ children, fallback, id }: SuspenseBoundaryProps): React.ReactElement;
+interface PPRShellProps {
+    children: React.ReactNode;
+    fallback?: React.ReactNode;
+}
+declare function PPRShell({ children, fallback }: PPRShellProps): React.ReactElement;
+interface PPRRenderResult {
+    staticShell: string;
+    dynamicParts: Map<string, () => Promise<string>>;
+    fullHtml: string;
+}
+declare function prerenderWithPPR(Component: React.ComponentType<any>, props: any, config?: PPRConfig): Promise<PPRRenderResult>;
+declare function streamPPR(staticShell: string, dynamicParts: Map<string, () => Promise<string>>, options?: {
+    onError?: (error: Error) => string;
+}): Promise<ReadableStream<Uint8Array>>;
+declare function pprFetch(input: RequestInfo | URL, init?: RequestInit & {
+    cache?: 'force-cache' | 'no-store' | 'no-cache';
+    next?: {
+        revalidate?: number;
+        tags?: string[];
+    };
+}): Promise<Response>;
+declare const experimental_ppr = true;
+interface PPRPageConfig {
+    experimental_ppr?: boolean;
+    revalidate?: number | false;
+    dynamic?: 'auto' | 'force-dynamic' | 'force-static' | 'error';
+    dynamicParams?: boolean;
+    fetchCache?: 'auto' | 'default-cache' | 'only-cache' | 'force-cache' | 'force-no-store' | 'default-no-store' | 'only-no-store';
+}
+type GenerateStaticParams<T = any> = () => Promise<T[]> | T[];
+declare function PPRLoading(): React.ReactElement;
+
+/**
+ * FlexiReact Font Optimization
+ *
+ * Optimized font loading with:
+ * - Automatic font subsetting
+ * - Preload hints generation
+ * - Font-display: swap by default
+ * - Self-hosted Google Fonts
+ * - Variable font support
+ * - CSS variable generation
+ */
+interface FontConfig {
+    family: string;
+    weight?: string | number | (string | number)[];
+    style?: 'normal' | 'italic' | 'oblique';
+    subsets?: string[];
+    display?: 'auto' | 'block' | 'swap' | 'fallback' | 'optional';
+    preload?: boolean;
+    fallback?: string[];
+    variable?: string;
+    adjustFontFallback?: boolean;
+}
+interface FontResult {
+    className: string;
+    style: {
+        fontFamily: string;
+        fontWeight?: number | string;
+        fontStyle?: string;
+    };
+    variable?: string;
+}
+declare const googleFonts: {
+    Inter: {
+        weights: number[];
+        variable: boolean;
+        subsets: string[];
+    };
+    Roboto: {
+        weights: number[];
+        variable: boolean;
+        subsets: string[];
+    };
+    'Open Sans': {
+        weights: number[];
+        variable: boolean;
+        subsets: string[];
+    };
+    Poppins: {
+        weights: number[];
+        variable: boolean;
+        subsets: string[];
+    };
+    Montserrat: {
+        weights: number[];
+        variable: boolean;
+        subsets: string[];
+    };
+    'Fira Code': {
+        weights: number[];
+        variable: boolean;
+        subsets: string[];
+    };
+    'JetBrains Mono': {
+        weights: number[];
+        variable: boolean;
+        subsets: string[];
+    };
+    Geist: {
+        weights: number[];
+        variable: boolean;
+        subsets: string[];
+    };
+    'Geist Mono': {
+        weights: number[];
+        variable: boolean;
+        subsets: string[];
+    };
+};
+declare function generateFontCSS(config: FontConfig): string;
+declare function generateFontPreloadTags(fonts: FontConfig[]): string;
+declare function createFont(config: FontConfig): FontResult;
+declare function googleFont(config: FontConfig): FontResult;
+declare function localFont(config: FontConfig & {
+    src: string | {
+        path: string;
+        weight?: string | number;
+        style?: string;
+    }[];
+}): FontResult;
+declare function handleFontRequest(req: any, res: any): Promise<void>;
+declare const fonts: {
+    inter: (config?: Partial<FontConfig>) => FontResult;
+    roboto: (config?: Partial<FontConfig>) => FontResult;
+    openSans: (config?: Partial<FontConfig>) => FontResult;
+    poppins: (config?: Partial<FontConfig>) => FontResult;
+    montserrat: (config?: Partial<FontConfig>) => FontResult;
+    geist: (config?: Partial<FontConfig>) => FontResult;
+    firaCode: (config?: Partial<FontConfig>) => FontResult;
+    jetbrainsMono: (config?: Partial<FontConfig>) => FontResult;
+    geistMono: (config?: Partial<FontConfig>) => FontResult;
+};
+
+/**
+ * FlexiReact Metadata API
+ *
+ * Complete metadata management like Next.js:
+ * - Static and dynamic metadata
+ * - Open Graph / Twitter Cards
+ * - Robots / Sitemap
+ * - JSON-LD structured data
+ * - Viewport configuration
+ * - Icons and manifest
+ */
+interface Metadata {
+    title?: string | {
+        default: string;
+        template?: string;
+        absolute?: string;
+    };
+    description?: string;
+    keywords?: string | string[];
+    authors?: Author | Author[];
+    creator?: string;
+    publisher?: string;
+    robots?: Robots | string;
+    icons?: Icons;
+    manifest?: string;
+    openGraph?: OpenGraph;
+    twitter?: Twitter;
+    verification?: Verification;
+    alternates?: Alternates;
+    appLinks?: AppLinks;
+    archives?: string | string[];
+    assets?: string | string[];
+    bookmarks?: string | string[];
+    category?: string;
+    classification?: string;
+    other?: Record<string, string | string[]>;
+    viewport?: Viewport | string;
+    themeColor?: ThemeColor | ThemeColor[];
+    colorScheme?: 'normal' | 'light' | 'dark' | 'light dark' | 'dark light';
+    formatDetection?: FormatDetection;
+    metadataBase?: URL | string;
+    generator?: string;
+    applicationName?: string;
+    referrer?: 'no-referrer' | 'origin' | 'no-referrer-when-downgrade' | 'origin-when-cross-origin' | 'same-origin' | 'strict-origin' | 'strict-origin-when-cross-origin' | 'unsafe-url';
+}
+interface Author {
+    name?: string;
+    url?: string;
+}
+interface Robots {
+    index?: boolean;
+    follow?: boolean;
+    noarchive?: boolean;
+    nosnippet?: boolean;
+    noimageindex?: boolean;
+    nocache?: boolean;
+    googleBot?: Robots | string;
+}
+interface Icons {
+    icon?: IconDescriptor | IconDescriptor[];
+    shortcut?: IconDescriptor | IconDescriptor[];
+    apple?: IconDescriptor | IconDescriptor[];
+    other?: IconDescriptor[];
+}
+interface IconDescriptor {
+    url: string;
+    type?: string;
+    sizes?: string;
+    color?: string;
+    rel?: string;
+    media?: string;
+}
+interface OpenGraph {
+    type?: 'website' | 'article' | 'book' | 'profile' | 'music.song' | 'music.album' | 'music.playlist' | 'music.radio_station' | 'video.movie' | 'video.episode' | 'video.tv_show' | 'video.other';
+    url?: string;
+    title?: string;
+    description?: string;
+    siteName?: string;
+    locale?: string;
+    images?: OGImage | OGImage[];
+    videos?: OGVideo | OGVideo[];
+    audio?: OGAudio | OGAudio[];
+    determiner?: 'a' | 'an' | 'the' | 'auto' | '';
+    publishedTime?: string;
+    modifiedTime?: string;
+    expirationTime?: string;
+    authors?: string | string[];
+    section?: string;
+    tags?: string[];
+}
+interface OGImage {
+    url: string;
+    secureUrl?: string;
+    type?: string;
+    width?: number;
+    height?: number;
+    alt?: string;
+}
+interface OGVideo {
+    url: string;
+    secureUrl?: string;
+    type?: string;
+    width?: number;
+    height?: number;
+}
+interface OGAudio {
+    url: string;
+    secureUrl?: string;
+    type?: string;
+}
+interface Twitter {
+    card?: 'summary' | 'summary_large_image' | 'app' | 'player';
+    site?: string;
+    siteId?: string;
+    creator?: string;
+    creatorId?: string;
+    title?: string;
+    description?: string;
+    images?: string | TwitterImage | (string | TwitterImage)[];
+    app?: TwitterApp;
+    player?: TwitterPlayer;
+}
+interface TwitterImage {
+    url: string;
+    alt?: string;
+}
+interface TwitterApp {
+    id?: {
+        iphone?: string;
+        ipad?: string;
+        googleplay?: string;
+    };
+    name?: string;
+    url?: {
+        iphone?: string;
+        ipad?: string;
+        googleplay?: string;
+    };
+}
+interface TwitterPlayer {
+    url: string;
+    width?: number;
+    height?: number;
+    stream?: string;
+}
+interface Verification {
+    google?: string | string[];
+    yahoo?: string | string[];
+    yandex?: string | string[];
+    me?: string | string[];
+    other?: Record<string, string | string[]>;
+}
+interface Alternates {
+    canonical?: string;
+    languages?: Record<string, string>;
+    media?: Record<string, string>;
+    types?: Record<string, string>;
+}
+interface AppLinks {
+    ios?: AppLink | AppLink[];
+    iphone?: AppLink | AppLink[];
+    ipad?: AppLink | AppLink[];
+    android?: AppLink | AppLink[];
+    windows_phone?: AppLink | AppLink[];
+    windows?: AppLink | AppLink[];
+    windows_universal?: AppLink | AppLink[];
+    web?: AppLink | AppLink[];
+}
+interface AppLink {
+    url: string;
+    app_store_id?: string;
+    app_name?: string;
+}
+interface Viewport {
+    width?: number | 'device-width';
+    height?: number | 'device-height';
+    initialScale?: number;
+    minimumScale?: number;
+    maximumScale?: number;
+    userScalable?: boolean;
+    viewportFit?: 'auto' | 'cover' | 'contain';
+    interactiveWidget?: 'resizes-visual' | 'resizes-content' | 'overlays-content';
+}
+interface ThemeColor {
+    color: string;
+    media?: string;
+}
+interface FormatDetection {
+    telephone?: boolean;
+    date?: boolean;
+    address?: boolean;
+    email?: boolean;
+    url?: boolean;
+}
+declare function generateMetadataTags(metadata: Metadata, baseUrl?: string): string;
+declare function mergeMetadata(parent: Metadata, child: Metadata): Metadata;
+declare function generateJsonLd(data: Record<string, any>): string;
+declare const jsonLd: {
+    website: (config: {
+        name: string;
+        url: string;
+        description?: string;
+    }) => {
+        '@context': string;
+        '@type': string;
+        name: string;
+        url: string;
+        description: string | undefined;
+    };
+    article: (config: {
+        headline: string;
+        description?: string;
+        image?: string | string[];
+        datePublished: string;
+        dateModified?: string;
+        author: {
+            name: string;
+            url?: string;
+        } | {
+            name: string;
+            url?: string;
+        }[];
+    }) => {
+        '@context': string;
+        '@type': string;
+        headline: string;
+        description: string | undefined;
+        image: string | string[] | undefined;
+        datePublished: string;
+        dateModified: string;
+        author: {
+            name: string;
+            url?: string;
+            '@type': string;
+        }[] | {
+            name: string;
+            url?: string;
+            '@type': string;
+        };
+    };
+    organization: (config: {
+        name: string;
+        url: string;
+        logo?: string;
+        sameAs?: string[];
+    }) => {
+        '@context': string;
+        '@type': string;
+        name: string;
+        url: string;
+        logo: string | undefined;
+        sameAs: string[] | undefined;
+    };
+    product: (config: {
+        name: string;
+        description?: string;
+        image?: string | string[];
+        brand?: string;
+        offers?: {
+            price: number;
+            priceCurrency: string;
+            availability?: string;
+        };
+    }) => {
+        '@context': string;
+        '@type': string;
+        name: string;
+        description: string | undefined;
+        image: string | string[] | undefined;
+        brand: {
+            '@type': string;
+            name: string;
+        } | undefined;
+        offers: {
+            '@type': string;
+            price: number;
+            priceCurrency: string;
+            availability: string;
+        } | undefined;
+    };
+    breadcrumb: (items: {
+        name: string;
+        url: string;
+    }[]) => {
+        '@context': string;
+        '@type': string;
+        itemListElement: {
+            '@type': string;
+            position: number;
+            name: string;
+            item: string;
+        }[];
+    };
+};
+
+/**
+ * FlexiReact Image Optimization
+ *
+ * Optimized image component with:
+ * - Automatic WebP/AVIF conversion
+ * - Responsive srcset generation
+ * - Lazy loading with blur placeholder
+ * - Priority loading for LCP images
+ * - Automatic width/height to prevent CLS
+ */
+
+interface ImageConfig {
+    domains: string[];
+    deviceSizes: number[];
+    imageSizes: number[];
+    formats: ('webp' | 'avif' | 'png' | 'jpeg')[];
+    minimumCacheTTL: number;
+    dangerouslyAllowSVG: boolean;
+    quality: number;
+    cacheDir: string;
+}
+declare const defaultImageConfig: ImageConfig;
+interface ImageProps {
+    src: string;
+    alt: string;
+    width?: number;
+    height?: number;
+    fill?: boolean;
+    sizes?: string;
+    quality?: number;
+    priority?: boolean;
+    placeholder?: 'blur' | 'empty' | 'data:image/...';
+    blurDataURL?: string;
+    loading?: 'lazy' | 'eager';
+    className?: string;
+    style?: React.CSSProperties;
+    onLoad?: () => void;
+    onError?: () => void;
+    unoptimized?: boolean;
+}
+declare function generateBlurPlaceholder(imagePath: string): Promise<string>;
+declare function getImageDimensions(src: string): Promise<{
+    width: number;
+    height: number;
+} | null>;
+declare function generateSrcSet(src: string, widths: number[], quality?: number): string;
+declare function handleImageOptimization(req: any, res: any, config?: Partial<ImageConfig>): Promise<void>;
+declare function createImageComponent(config?: Partial<ImageConfig>): (props: ImageProps) => React.ReactElement;
+declare const Image: (props: ImageProps) => React.ReactElement;
+interface ImageLoader {
+    (props: {
+        src: string;
+        width: number;
+        quality?: number;
+    }): string;
+}
+declare const imageLoaders: {
+    default: ({ src, width, quality }: {
+        src: string;
+        width: number;
+        quality?: number;
+    }) => string;
+    cloudinary: ({ src, width, quality }: {
+        src: string;
+        width: number;
+        quality?: number;
+    }) => string;
+    imgix: ({ src, width, quality }: {
+        src: string;
+        width: number;
+        quality?: number;
+    }) => string;
+    vercel: ({ src, width, quality }: {
+        src: string;
+        width: number;
+        quality?: number;
+    }) => string;
+    cloudflare: ({ src, width, quality }: {
+        src: string;
+        width: number;
+        quality?: number;
+    }) => string;
+};
+
+/**
+ * FlexiReact Hooks - React 19 Native
+ *
+ * This module provides React 19 hooks re-exports and FlexiReact-specific
+ * hook utilities for enhanced developer experience.
+ */
+
+/**
+ * Async data fetching hook using React 19's use()
+ *
+ * @example
+ * ```tsx
+ * // In a Server Component or with Suspense boundary
+ * function UserProfile({ userId }: { userId: string }) {
+ *   const user = useAsyncData(fetchUser(userId));
+ *   return <div>{user.name}</div>;
+ * }
+ * ```
+ */
+declare function useAsyncData<T>(promise: Promise<T>): T;
+/**
+ * Optimistic mutation helper with typed update function
+ *
+ * @example
+ * ```tsx
+ * function TodoList({ todos }: { todos: Todo[] }) {
+ *   const [optimisticTodos, addOptimistic] = useOptimisticMutation(
+ *     todos,
+ *     (state, newTodo: Todo) => [...state, { ...newTodo, pending: true }]
+ *   );
+ *
+ *   async function addTodo(todo: Todo) {
+ *     addOptimistic(todo);
+ *     await saveTodo(todo);
+ *   }
+ * }
+ * ```
+ */
+declare function useOptimisticMutation<T, M>(currentState: T, updateFn: (state: T, mutation: M) => T): [T, (mutation: M) => void];
+/**
+ * Resource preloading for Suspense optimization
+ *
+ * @example
+ * ```tsx
+ * // Preload data before it's needed
+ * const userResource = preloadResource(() => fetchUser(userId));
+ *
+ * // Later, use it with Suspense
+ * function UserCard() {
+ *   const user = useAsyncData(userResource);
+ *   return <div>{user.name}</div>;
+ * }
+ * ```
+ */
+declare function preloadResource<T>(fetcher: () => Promise<T>): Promise<T>;
+
+/**
+ * FlexiReact Server Helpers
+ * Utility functions for server-side operations
+ */
+/**
+ * Custom error classes for control flow
+ */
+declare class RedirectError extends Error {
+    readonly url: string;
+    readonly statusCode: number;
+    readonly type: "redirect";
+    constructor(url: string, statusCode?: number);
+}
+declare class NotFoundError extends Error {
+    readonly type: "notFound";
+    constructor(message?: string);
+}
+/**
+ * Redirect to a different URL
+ * @param url - The URL to redirect to
+ * @param type - 'replace' (307) or 'push' (308) for permanent
+ *
+ * @example
+ * ```tsx
+ * import { redirect } from '@flexireact/core';
+ *
+ * export default function ProtectedPage() {
+ *   const user = getUser();
+ *   if (!user) {
+ *     redirect('/login');
+ *   }
+ *   return <Dashboard user={user} />;
+ * }
+ * ```
+ */
+declare function redirect(url: string, type?: 'replace' | 'permanent'): never;
+/**
+ * Trigger a 404 Not Found response
+ *
+ * @example
+ * ```tsx
+ * import { notFound } from '@flexireact/core';
+ *
+ * export default function ProductPage({ params }) {
+ *   const product = getProduct(params.id);
+ *   if (!product) {
+ *     notFound();
+ *   }
+ *   return <Product data={product} />;
+ * }
+ * ```
+ */
+declare function notFound(message?: string): never;
+/**
+ * Create a JSON response
+ *
+ * @example
+ * ```ts
+ * // In API route
+ * export function GET() {
+ *   return json({ message: 'Hello' });
+ * }
+ *
+ * export function POST() {
+ *   return json({ error: 'Bad request' }, { status: 400 });
+ * }
+ * ```
+ */
+declare function json<T>(data: T, options?: {
+    status?: number;
+    headers?: Record<string, string>;
+}): Response;
+/**
+ * Create an HTML response
+ */
+declare function html(content: string, options?: {
+    status?: number;
+    headers?: Record<string, string>;
+}): Response;
+/**
+ * Create a text response
+ */
+declare function text(content: string, options?: {
+    status?: number;
+    headers?: Record<string, string>;
+}): Response;
+interface CookieOptions {
+    /** Max age in seconds */
+    maxAge?: number;
+    /** Expiration date */
+    expires?: Date;
+    /** Cookie path */
+    path?: string;
+    /** Cookie domain */
+    domain?: string;
+    /** Secure flag (HTTPS only) */
+    secure?: boolean;
+    /** HttpOnly flag */
+    httpOnly?: boolean;
+    /** SameSite policy */
+    sameSite?: 'strict' | 'lax' | 'none';
+}
+/**
+ * Cookie utilities for server-side operations
+ */
+declare const cookies: {
+    /**
+     * Parse cookies from a cookie header string
+     */
+    parse(cookieHeader: string): Record<string, string>;
+    /**
+     * Get a cookie value from request headers
+     */
+    get(request: Request, name: string): string | undefined;
+    /**
+     * Get all cookies from request
+     */
+    getAll(request: Request): Record<string, string>;
+    /**
+     * Serialize a cookie for Set-Cookie header
+     */
+    serialize(name: string, value: string, options?: CookieOptions): string;
+    /**
+     * Create a Set-Cookie header value
+     */
+    set(name: string, value: string, options?: CookieOptions): string;
+    /**
+     * Create a cookie deletion header
+     */
+    delete(name: string, options?: Omit<CookieOptions, "maxAge" | "expires">): string;
+};
+/**
+ * Headers utilities for server-side operations
+ */
+declare const headers: {
+    /**
+     * Create a new Headers object with common defaults
+     */
+    create(init?: HeadersInit): Headers;
+    /**
+     * Get a header value from request
+     */
+    get(request: Request, name: string): string | null;
+    /**
+     * Get all headers as an object
+     */
+    getAll(request: Request): Record<string, string>;
+    /**
+     * Check if request has a specific header
+     */
+    has(request: Request, name: string): boolean;
+    /**
+     * Get content type from request
+     */
+    contentType(request: Request): string | null;
+    /**
+     * Check if request accepts JSON
+     */
+    acceptsJson(request: Request): boolean;
+    /**
+     * Check if request is AJAX/fetch
+     */
+    isAjax(request: Request): boolean;
+    /**
+     * Get authorization header
+     */
+    authorization(request: Request): {
+        type: string;
+        credentials: string;
+    } | null;
+    /**
+     * Get bearer token from authorization header
+     */
+    bearerToken(request: Request): string | null;
+    /**
+     * Common security headers
+     */
+    security(): Record<string, string>;
+    /**
+     * CORS headers
+     */
+    cors(options?: {
+        origin?: string;
+        methods?: string[];
+        headers?: string[];
+        credentials?: boolean;
+        maxAge?: number;
+    }): Record<string, string>;
+    /**
+     * Cache control headers
+     */
+    cache(options?: {
+        maxAge?: number;
+        sMaxAge?: number;
+        staleWhileRevalidate?: number;
+        private?: boolean;
+        noStore?: boolean;
+    }): Record<string, string>;
+};
+/**
+ * Parse JSON body from request
+ */
+declare function parseJson<T = unknown>(request: Request): Promise<T>;
+/**
+ * Parse form data from request
+ */
+declare function parseFormData(request: Request): Promise<FormData>;
+/**
+ * Parse URL search params
+ */
+declare function parseSearchParams(request: Request): URLSearchParams;
+/**
+ * Get request method
+ */
+declare function getMethod(request: Request): string;
+/**
+ * Get request pathname
+ */
+declare function getPathname(request: Request): string;
+/**
+ * Check if request method matches
+ */
+declare function isMethod(request: Request, method: string | string[]): boolean;
+
+/**
+ * FlexiReact Server Actions
+ *
+ * React 19 native actions with FlexiReact enhancements.
+ *
+ * Usage:
+ * ```tsx
+ * // In a server file (actions.ts)
+ * 'use server';
+ *
+ * export async function createUser(prevState: any, formData: FormData) {
+ *   const name = formData.get('name');
+ *   // Save to database...
+ *   return { success: true, id: 123 };
+ * }
+ *
+ * // In a client component - React 19 style
+ * 'use client';
+ * import { useActionState } from '@flexireact/core';
+ * import { createUser } from './actions';
+ *
+ * function Form() {
+ *   const [state, formAction, isPending] = useActionState(createUser, null);
+ *   return (
+ *     <form action={formAction}>
+ *       <input name="name" />
+ *       <button type="submit" disabled={isPending}>Create</button>
+ *     </form>
+ *   );
+ * }
+ * ```
+ */
+
+declare global {
+    var __FLEXI_ACTIONS__: Record<string, ServerActionFunction>;
+    var __FLEXI_ACTION_CONTEXT__: ActionContext | null;
+}
+interface ActionContext {
+    request: Request;
+    cookies: typeof cookies;
+    headers: typeof headers;
+    redirect: typeof redirect;
+    notFound: typeof notFound;
+}
+type ServerActionFunction = (...args: any[]) => Promise<any>;
+interface ActionResult<T = any> {
+    success: boolean;
+    data?: T;
+    error?: string;
+    redirect?: string;
+}
+/**
+ * Decorator to mark a function as a server action
+ */
+declare function serverAction<T extends ServerActionFunction>(fn: T, actionId?: string): T;
+/**
+ * Register a server action
+ */
+declare function registerAction(id: string, fn: ServerActionFunction): void;
+/**
+ * Get a registered action
+ */
+declare function getAction(id: string): ServerActionFunction | undefined;
+/**
+ * Execute a server action on the server
+ */
+declare function executeAction(actionId: string, args: any[], context?: Partial<ActionContext>): Promise<ActionResult>;
+/**
+ * Call a server action from the client
+ */
+declare function callServerAction(actionId: string, args: any[]): Promise<ActionResult>;
+/**
+ * Hook to get the current action context
+ */
+declare function useActionContext(): ActionContext | null;
+/**
+ * Create a form action handler
+ * Wraps a server action for use with HTML forms
+ */
+declare function formAction<T>(action: (formData: FormData) => Promise<T>): (formData: FormData) => Promise<ActionResult<T>>;
+declare function useFlexiAction<State, Payload>(action: (state: Awaited<State>, payload: Payload) => State | Promise<State>, initialState: Awaited<State>, permalink?: string): [state: Awaited<State>, dispatch: (payload: Payload) => void, isPending: boolean];
+/**
+ * @deprecated Since v3.1 - Use `useActionState` from React 19 instead.
+ * This function will be removed in v4.0.
+ *
+ * Migration:
+ * ```tsx
+ * // Before (React 18)
+ * const formState = createFormState(submitAction, null);
+ *
+ * // After (React 19)
+ * const [state, formAction, isPending] = useActionState(submitAction, null);
+ * ```
+ */
+declare function createFormState<T>(action: (formData: FormData) => Promise<ActionResult<T>>, initialState?: T | null): {
+    action: (formData: FormData) => Promise<ActionResult<T>>;
+    initialState: T | null;
+    pending: boolean;
+    error: string | null;
+    data: T | null;
+};
+/**
+ * Bind arguments to a server action
+ * Creates a new action with pre-filled arguments
+ */
+declare function bindArgs<T extends ServerActionFunction>(action: T, ...boundArgs: any[]): T;
+
+/**
+ * FlexiReact DevTools
+ * Advanced development tools for debugging and performance monitoring
+ */
+
+interface RouteInfo {
+    path: string;
+    component: string;
+    params: Record<string, string>;
+    query: Record<string, string>;
+    loadTime: number;
+}
+interface ComponentInfo {
+    name: string;
+    renderCount: number;
+    lastRenderTime: number;
+    props: Record<string, any>;
+    isIsland: boolean;
+}
+interface NetworkRequest {
+    id: string;
+    url: string;
+    method: string;
+    status: number;
+    duration: number;
+    size: number;
+    timestamp: number;
+    type: 'fetch' | 'xhr' | 'ssr' | 'action';
+}
+interface PerformanceMetric {
+    name: string;
+    value: number;
+    rating: 'good' | 'needs-improvement' | 'poor';
+}
+declare const devtools: {
+    trackRoute(info: RouteInfo): void;
+    trackComponent(name: string, info: Partial<ComponentInfo>): void;
+    trackRequest(request: NetworkRequest): void;
+    trackMetric(metric: PerformanceMetric): void;
+    log(level: "info" | "warn" | "error" | "debug", message: string): void;
+    getState(): {
+        routes: RouteInfo[];
+        components: ComponentInfo[];
+        network: NetworkRequest[];
+        performance: PerformanceMetric[];
+        logs: {
+            level: string;
+            message: string;
+            timestamp: number;
+        }[];
+    };
+    subscribe(listener: () => void): () => void;
+    notify(): void;
+    clear(): void;
+};
+declare function initPerformanceMonitoring(): void;
+declare function initNetworkInterceptor(): void;
+declare function DevToolsOverlay(): React.ReactElement | null;
+
+/**
+ * FlexiReact v4 - Main Entry Point
+ * A modern React framework with RSC, SSG, Islands, and more
+ */
+
+declare const VERSION = "4.0.0";
+declare const _default: {
+    VERSION: string;
+    createServer: typeof createServer;
+};
+
+export { type ActionContext, type ActionResult, type Author, type CacheEntry, type CacheOptions, ClientBoundary, type CookieOptions, DevToolsOverlay, type EdgeAppConfig, type EdgeContext, type EdgeHandler, type EdgeMiddleware, type FlexiConfig, FlexiHeaders, FlexiRequest, FlexiResponse, type FontConfig, type FontResult, type GenerateStaticParams, ISRManager, type Icons, Image, type ImageConfig, type ImageLoader, type ImageProps, Island, type LayoutProps, LoadStrategy, type Metadata, MiddlewareRequest, MiddlewareResponse, NotFoundError, type OpenGraph, PPRBoundary, type PPRConfig, PPRLoading, type PPRPageConfig, type PPRRenderResult, PPRShell, type PageProps, PluginHooks, PluginManager, RSC_CONTENT_TYPE, RedirectError, type Robots, type Route, RouteType, type RouteType$1 as RouteTypeEnum, type RuntimeCapabilities, type RuntimeEnvironment, SSGResult, type ServerActionFunction, ServerBoundary, type Twitter, VERSION, type Viewport, bindArgs, buildRouteTree, builtinPlugins, cacheFunction, callServerAction, cleanDir, composeMiddleware, cookies, copyDir, createEdgeApp as createApp, createClientReference, createDeferred, createEdgeApp, createFont, createFormState, createImageComponent, createIsland, createLazyIsland, createRequestContext, createServer, createServerAction, debounce, _default as default, defaultImageConfig, definePlugin, detectRuntime, devtools, dynamic, runtime as edgeRuntimeInfo, ensureDir, escapeHtml, executeAction, experimental_ppr, findFiles, findRouteLayouts, fonts, formAction, formatBytes, formatTime, generateAdvancedHydrationScript, generateBlurPlaceholder, generateFontCSS, generateFontPreloadTags, generateHash, generateHydrationScript, generateJsonLd, generateMetadataTags, generateSrcSet, generateStaticSite, getAction, getImageDimensions, getMethod, getPathname, getRegisteredIslands, getRuntimeCapabilities, googleFont, googleFonts, handleFontRequest, handleImageOptimization, handleServerAction, headers, html, imageLoaders, initCache, initNetworkInterceptor, initPerformanceMonitoring, isClientComponent, isIsland, isMethod, isServerComponent, json, jsonLd, loadMiddleware, loadPlugins, localFont, matchRoute, mergeMetadata, middlewares, notFound, parseFormData, parseJson, parseSearchParams, pluginManager, pprFetch, preloadResource, prerenderWithPPR, processServerComponent, reactCache, redirect, registerAction, renderError, renderLoading, renderPage, renderPageStream, revalidatePath, revalidateTag, runMiddleware, serializeRSCPayload, serverAction, sleep, cache as smartCache, staticComponent, streamPPR, streamToResponse, text, unstable_cache, useActionContext, useAsyncData, useFlexiAction, useOptimisticMutation, useParams, usePathname, useQuery, useRequest };