@teamvelix/velix 5.0.1

package/dist/index.d.ts

@@ -0,0 +1,792 @@
+export { VelixConfig, VelixConfigSchema, defaultConfig, defineConfig, loadConfig, resolvePaths } from './config.js';
+import * as http from 'http';
+import { IncomingMessage, ServerResponse } from 'http';
+import React, { ReactNode, ComponentType, ImgHTMLAttributes } from 'react';
+export { use, useActionState, useOptimistic } from 'react';
+export { a as PluginHooks, P as PluginManager, V as VelixServer, c as createServer, d as definePlugin, l as loadPlugins, p as pluginManager, t as tailwindPlugin } from './index-l0dwPa62.js';
+export { Island, LoadStrategy, createIsland, createLazyIsland, generateAdvancedHydrationScript, generateHydrationScript, getRegisteredIslands } from './islands/index.js';
+export { L as LayoutContext, f as Link, R as RequestContext, d as RouteContext, e as createRequestContext, h as hydrate, r as router, u as useParams, b as usePathname, a as useQuery, c as useRequest, g as useRouter } from './index-C4udNtpZ.js';
+export { build } from './build/index.js';
+export { useFormStatus } from 'react-dom';
+import 'zod';
+
+/**
+ * Velix v5 Core Types
+ * Comprehensive type definitions for the framework
+ */
+
+type RouteType = 'page' | 'api' | 'layout' | 'loading' | 'error' | 'not-found';
+interface Route {
+    type: RouteType;
+    path: string;
+    filePath: string;
+    pattern: RegExp;
+    segments: string[];
+    layout?: string | null;
+    loading?: string | null;
+    error?: string | null;
+    notFound?: string | null;
+    template?: string | null;
+    middleware?: string | null;
+    isServerComponent?: boolean;
+    isClientComponent?: boolean;
+    isIsland?: boolean;
+    params?: Record<string, string>;
+}
+interface RouteTree {
+    pages: Route[];
+    api: Route[];
+    layouts: Map<string, string>;
+    tree: Record<string, unknown>;
+    appRoutes: Route[];
+    rootLayout?: string;
+}
+interface RouteMatch {
+    route: Route;
+    params: Record<string, string>;
+}
+type Request$1 = IncomingMessage & {
+    params?: Record<string, string>;
+    query?: Record<string, string>;
+    body?: unknown;
+    json?: () => Promise<unknown>;
+};
+type Response$1 = ServerResponse & {
+    json?: (data: unknown) => void;
+    send?: (data: string) => void;
+    status?: (code: number) => Response$1;
+};
+type NextFunction = () => void | Promise<void>;
+type Middleware = (req: Request$1, res: Response$1, next: NextFunction) => void | Promise<void>;
+type ApiHandler = (req: Request$1, res: Response$1) => void | Promise<void>;
+type ActionState<T> = T | Promise<T>;
+type ServerAction<State, Payload = FormData> = (prevState: Awaited<State>, payload: Payload) => State | Promise<State>;
+interface TypedActionResult<T> {
+    success: boolean;
+    data?: T;
+    error?: string;
+    errors?: Record<string, string[]>;
+    redirect?: string;
+}
+interface PageProps {
+    params?: Record<string, string>;
+    searchParams?: Record<string, string>;
+}
+interface LayoutProps {
+    children: ReactNode;
+    params?: Record<string, string>;
+}
+interface ErrorProps {
+    error: Error;
+    reset: () => void;
+}
+interface LoadingProps {
+}
+interface NotFoundProps {
+}
+type PageComponent = ComponentType<PageProps>;
+type LayoutComponent = ComponentType<LayoutProps>;
+type ErrorComponent = ComponentType<ErrorProps>;
+type LoadingComponent = ComponentType<LoadingProps>;
+type NotFoundComponent = ComponentType<NotFoundProps>;
+interface IslandConfig {
+    name: string;
+    component: ComponentType<unknown>;
+    props?: Record<string, unknown>;
+    hydrate?: 'load' | 'idle' | 'visible' | 'media' | 'interaction';
+    media?: string;
+}
+interface IslandManifest {
+    islands: Map<string, IslandConfig>;
+}
+interface BuildOptions {
+    outDir?: string;
+    minify?: boolean;
+    sourcemap?: boolean;
+    target?: string;
+}
+interface BuildResult {
+    success: boolean;
+    errors?: string[];
+    warnings?: string[];
+    duration?: number;
+}
+interface StaticPath {
+    params: Record<string, string>;
+}
+interface StaticProps {
+    props: Record<string, unknown>;
+    revalidate?: number | false;
+    notFound?: boolean;
+    redirect?: {
+        destination: string;
+        permanent?: boolean;
+    };
+}
+interface VelixPlugin {
+    name: string;
+    setup?: (config: any) => void | Promise<void>;
+    transform?: (code: string, id: string) => string | null | Promise<string | null>;
+    buildStart?: () => void | Promise<void>;
+    buildEnd?: () => void | Promise<void>;
+}
+interface Metadata$1 {
+    title?: string;
+    description?: string;
+    keywords?: string[];
+    author?: string;
+    canonical?: string;
+    openGraph?: {
+        title?: string;
+        description?: string;
+        image?: string;
+        url?: string;
+        type?: string;
+        siteName?: string;
+    };
+    twitter?: {
+        card?: 'summary' | 'summary_large_image' | 'app' | 'player';
+        title?: string;
+        description?: string;
+        image?: string;
+        site?: string;
+        creator?: string;
+    };
+    robots?: {
+        index?: boolean;
+        follow?: boolean;
+    };
+}
+
+/**
+ * Velix v5 Server Helpers
+ * Utility functions for server-side operations
+ */
+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
+ *
+ * @example
+ * ```tsx
+ * import { redirect } from 'velix';
+ *
+ * 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
+ */
+declare function notFound(message?: string): never;
+/**
+ * Create a JSON response
+ */
+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 {
+    maxAge?: number;
+    expires?: Date;
+    path?: string;
+    domain?: string;
+    secure?: boolean;
+    httpOnly?: boolean;
+    sameSite?: 'strict' | 'lax' | 'none';
+}
+declare const cookies: {
+    parse(cookieHeader: string): Record<string, string>;
+    get(request: Request, name: string): string | undefined;
+    getAll(request: Request): Record<string, string>;
+    serialize(name: string, value: string, options?: CookieOptions): string;
+    set(name: string, value: string, options?: CookieOptions): string;
+    delete(name: string, options?: Omit<CookieOptions, "maxAge" | "expires">): string;
+};
+declare const headers: {
+    create(init?: HeadersInit): Headers;
+    get(request: Request, name: string): string | null;
+    getAll(request: Request): Record<string, string>;
+    has(request: Request, name: string): boolean;
+    contentType(request: Request): string | null;
+    acceptsJson(request: Request): boolean;
+    isAjax(request: Request): boolean;
+    authorization(request: Request): {
+        type: string;
+        credentials: string;
+    } | null;
+    bearerToken(request: Request): string | null;
+    security(): Record<string, string>;
+    cors(options?: {
+        origin?: string;
+        methods?: string[];
+        headers?: string[];
+        credentials?: boolean;
+        maxAge?: number;
+    }): Record<string, string>;
+    cache(options?: {
+        maxAge?: number;
+        sMaxAge?: number;
+        staleWhileRevalidate?: number;
+        private?: boolean;
+        noStore?: boolean;
+    }): Record<string, string>;
+};
+declare function parseJson<T = unknown>(request: Request): Promise<T>;
+declare function parseFormData(request: Request): Promise<FormData>;
+declare function parseSearchParams(request: Request): URLSearchParams;
+declare function getMethod(request: Request): string;
+declare function getPathname(request: Request): string;
+declare function isMethod(request: Request, method: string | string[]): boolean;
+
+/**
+ * Builds the complete route tree from the app/ directory
+ */
+declare function buildRouteTree(appDir: string): {
+    pages: any[];
+    api: any[];
+    layouts: Map<string, string>;
+    tree: Record<string, any>;
+    appRoutes: 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;
+}>;
+
+/**
+ * Velix v5 Middleware System
+ * Request processing pipeline with composable middleware
+ */
+interface MiddlewareRequest {
+    url: string;
+    method: string;
+    headers: Record<string, string | string[] | undefined>;
+    cookies: Record<string, string>;
+    params: Record<string, string>;
+    query: Record<string, string>;
+    body?: any;
+    raw: http.IncomingMessage;
+}
+interface MiddlewareResponse {
+    status: (code: number) => MiddlewareResponse;
+    header: (name: string, value: string) => MiddlewareResponse;
+    json: (data: any) => void;
+    redirect: (url: string, status?: number) => void;
+    rewrite: (url: string) => void;
+    next: () => Promise<void>;
+    _statusCode: number;
+    _headers: Record<string, string>;
+    _redirectUrl: string | null;
+    _rewriteUrl: string | null;
+    _ended: boolean;
+}
+type MiddlewareFunction = (req: MiddlewareRequest, res: MiddlewareResponse, next: () => Promise<void>) => void | Promise<void>;
+type MiddlewareResult = {
+    continue: boolean;
+    rewritten: boolean;
+};
+declare const middlewares: {
+    cors(options?: {
+        origin?: string | string[];
+        methods?: string[];
+        headers?: string[];
+        credentials?: boolean;
+        maxAge?: number;
+    }): MiddlewareFunction;
+    rateLimit(options?: {
+        windowMs?: number;
+        max?: number;
+        message?: string;
+    }): MiddlewareFunction;
+    security(): MiddlewareFunction;
+};
+/**
+ * Loads middleware from the project's middleware/ directory
+ */
+declare function loadMiddleware(projectRoot: string): Promise<MiddlewareFunction[]>;
+/**
+ * Runs middleware chain for a request
+ */
+declare function runMiddleware(req: http.IncomingMessage, res: http.ServerResponse, fns: MiddlewareFunction[]): Promise<MiddlewareResult>;
+/**
+ * Compose multiple middleware into one
+ */
+declare function composeMiddleware(...fns: MiddlewareFunction[]): MiddlewareFunction;
+
+/**
+ * Velix v5 Metadata & SEO System
+ *
+ * First-class SEO with automatic:
+ * - Meta tags, Open Graph, Twitter Cards
+ * - Canonical URLs, robots, sitemaps
+ * - JSON-LD structured data
+ * - Viewport, theme color, icons
+ */
+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;
+    viewport?: Viewport | string;
+    themeColor?: ThemeColor | ThemeColor[];
+    colorScheme?: 'normal' | 'light' | 'dark' | 'light dark' | 'dark light';
+    formatDetection?: FormatDetection;
+    metadataBase?: URL | string;
+    generator?: string;
+    applicationName?: string;
+    referrer?: string;
+    other?: Record<string, string | string[]>;
+}
+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?: string;
+    url?: string;
+    title?: string;
+    description?: string;
+    siteName?: string;
+    locale?: string;
+    images?: OGImage | OGImage[];
+    videos?: OGVideo | OGVideo[];
+    determiner?: string;
+    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 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)[];
+}
+interface TwitterImage {
+    url: string;
+    alt?: string;
+}
+interface Verification {
+    google?: string | string[];
+    yahoo?: string | string[];
+    yandex?: string | string[];
+    other?: Record<string, string | string[]>;
+}
+interface Alternates {
+    canonical?: string;
+    languages?: Record<string, string>;
+    media?: Record<string, string>;
+}
+interface Viewport {
+    width?: number | 'device-width';
+    height?: number | 'device-height';
+    initialScale?: number;
+    minimumScale?: number;
+    maximumScale?: number;
+    userScalable?: boolean;
+    viewportFit?: 'auto' | 'cover' | 'contain';
+}
+interface ThemeColor {
+    color: string;
+    media?: string;
+}
+interface FormatDetection {
+    telephone?: boolean;
+    date?: boolean;
+    address?: boolean;
+    email?: 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: (c: {
+        name: string;
+        url: string;
+        description?: string;
+    }) => {
+        '@context': string;
+        '@type': string;
+        name: string;
+        url: string;
+        description: string | undefined;
+    };
+    article: (c: {
+        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: (c: {
+        name: string;
+        url: string;
+        logo?: string;
+        sameAs?: string[];
+    }) => {
+        '@context': string;
+        '@type': string;
+        name: string;
+        url: string;
+        logo: string | undefined;
+        sameAs: string[] | undefined;
+    };
+    breadcrumb: (items: {
+        name: string;
+        url: string;
+    }[]) => {
+        '@context': string;
+        '@type': string;
+        itemListElement: {
+            '@type': string;
+            position: number;
+            name: string;
+            item: string;
+        }[];
+    };
+};
+/**
+ * Generate sitemap.xml content from routes
+ */
+declare function generateSitemap(routes: any[], baseUrl: string): string;
+/**
+ * Generate robots.txt content
+ */
+declare function generateRobotsTxt(baseUrl: string, options?: {
+    disallow?: string[];
+    allow?: string[];
+}): string;
+
+/**
+ * Velix v5 Server Actions
+ *
+ * React 19 native actions with Velix enhancements and security.
+ */
+
+declare global {
+    var __VELIX_ACTIONS__: Record<string, ServerActionFunction>;
+    var __VELIX_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;
+declare function registerAction(id: string, fn: ServerActionFunction): void;
+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>;
+declare function deserializeArgs(args: any[]): any[];
+declare function useActionContext(): ActionContext | null;
+declare function formAction<T>(action: (formData: FormData) => Promise<T>): (formData: FormData) => Promise<ActionResult<T>>;
+declare function useVelixAction<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];
+declare function bindArgs<T extends ServerActionFunction>(action: T, ...boundArgs: any[]): T;
+
+/**
+ * Velix v5 Revalidation & Cache Management
+ * Inspired by Next.js revalidatePath and revalidateTag
+ */
+type RevalidationType = 'path' | 'tag' | 'layout';
+declare class CacheManager {
+    private cache;
+    private tagIndex;
+    set(path: string, data: any, tags?: string[]): void;
+    get(path: string): any | null;
+    revalidatePath(path: string): void;
+    revalidateTag(tag: string): void;
+    clear(): void;
+    has(path: string): boolean;
+}
+declare const cacheManager: CacheManager;
+/**
+ * Revalidate a specific path
+ * @example
+ * ```ts
+ * import { revalidatePath } from 'velix/actions';
+ *
+ * await revalidatePath('/blog');
+ * await revalidatePath('/blog/[slug]', 'layout');
+ * ```
+ */
+declare function revalidatePath(path: string, type?: RevalidationType): void;
+/**
+ * Revalidate all paths with a specific cache tag
+ * @example
+ * ```ts
+ * import { revalidateTag } from 'velix/actions';
+ *
+ * await revalidateTag('blog-posts');
+ * ```
+ */
+declare function revalidateTag(tag: string): void;
+/**
+ * Unstable cache wrapper (experimental)
+ */
+declare function unstable_cache<T>(fn: () => Promise<T>, keys: string[], options?: {
+    tags?: string[];
+    revalidate?: number;
+}): () => Promise<T>;
+
+/**
+ * Velix v5 Hooks
+ * React 19 hooks re-exports and Velix-specific hook utilities
+ */
+
+/**
+ * Async data fetching hook using React 19's use()
+ *
+ * @example
+ * ```tsx
+ * 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
+ * const [optimisticTodos, addOptimistic] = useOptimisticMutation(
+ *   todos,
+ *   (state, newTodo: Todo) => [...state, { ...newTodo, pending: true }]
+ * );
+ * ```
+ */
+declare function useOptimisticMutation<T, M>(currentState: T, updateFn: (state: T, mutation: M) => T): [T, (mutation: M) => void];
+/**
+ * Resource preloading for Suspense optimization
+ */
+declare function preloadResource<T>(fetcher: () => Promise<T>): Promise<T>;
+
+interface ImageProps extends Omit<ImgHTMLAttributes<HTMLImageElement>, 'src' | 'srcSet'> {
+    src: string;
+    alt: string;
+    width?: number | string;
+    height?: number | string;
+    quality?: number;
+    priority?: boolean;
+    unoptimized?: boolean;
+}
+declare const Image: React.ForwardRefExoticComponent<ImageProps & React.RefAttributes<HTMLImageElement>>;
+
+/**
+ * Velix v5 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;
+/**
+ * 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;
+
+/**
+ * Velix v5 Logger
+ * Minimalist, professional output inspired by modern CLIs
+ */
+declare const logger: {
+    logo(): void;
+    serverStart(config: any, startTime?: number): void;
+    request(method: string, path: string, status: number, time: number, extra?: {
+        type?: string;
+    }): void;
+    info(msg: string): void;
+    success(msg: string): void;
+    warn(msg: string): void;
+    error(msg: string, err?: Error | null): void;
+    compile(file: string, time: number): void;
+    hmr(file: string): void;
+    plugin(name: string): void;
+    route(path: string, type: string): void;
+    divider(): void;
+    blank(): void;
+    portInUse(port: number | string): void;
+    build(stats: {
+        time: number;
+    }): void;
+};
+
+export { type ActionState, type ApiHandler, type BuildOptions, type BuildResult, type CookieOptions, type ErrorComponent, type ErrorProps, Image, type ImageProps, type IslandConfig, type IslandManifest, type LayoutComponent, type LayoutProps, type LoadingComponent, type LoadingProps, type Metadata$1 as Metadata, type Middleware, type NextFunction, type NotFoundComponent, NotFoundError, type NotFoundProps, type PageComponent, type PageProps, RedirectError, type Route, type RouteMatch, type RouteTree, type RouteType, type ServerAction, type StaticPath, type StaticProps, type TypedActionResult, type VelixPlugin, bindArgs, buildRouteTree, cacheManager, callServerAction, cleanDir, composeMiddleware, cookies, copyDir, debounce, deserializeArgs, ensureDir, escapeHtml, executeAction, findFiles, findRouteLayouts, formAction, formatBytes, formatTime, generateHash, generateJsonLd, generateMetadataTags, generateRobotsTxt, generateSitemap, getAction, getMethod, getPathname, headers, html, isClientComponent, isIsland as isIslandComponent, isMethod, isServerComponent, json, jsonLd, loadMiddleware, logger, matchRoute, mergeMetadata, middlewares, notFound, parseFormData, parseJson, parseSearchParams, preloadResource, redirect, registerAction, revalidatePath, revalidateTag, runMiddleware, serverAction, sleep, text, unstable_cache, useActionContext, useAsyncData, useOptimisticMutation, useVelixAction };