@teamvelix/velix-core 5.1.7

package/dist/index.d.ts

@@ -0,0 +1,1300 @@
+import { z } from 'zod';
+import * as http from 'http';
+import { IncomingMessage, ServerResponse } from 'http';
+
+/**
+ * Velix v5 Configuration System
+ * Handles loading, validation, and merging of velix.config.ts
+ */
+
+declare const VelixConfigSchema: z.ZodObject<{
+    app: z.ZodDefault<z.ZodObject<{
+        name: z.ZodDefault<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        url?: string | undefined;
+    }, {
+        url?: string | undefined;
+        name?: string | undefined;
+    }>>;
+    devtools: z.ZodDefault<z.ZodBoolean>;
+    server: z.ZodDefault<z.ZodObject<{
+        port: z.ZodDefault<z.ZodNumber>;
+        host: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        port: number;
+        host: string;
+    }, {
+        port?: number | undefined;
+        host?: string | undefined;
+    }>>;
+    routing: z.ZodDefault<z.ZodObject<{
+        trailingSlash: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        trailingSlash: boolean;
+    }, {
+        trailingSlash?: boolean | undefined;
+    }>>;
+    seo: z.ZodDefault<z.ZodObject<{
+        sitemap: z.ZodDefault<z.ZodBoolean>;
+        robots: z.ZodDefault<z.ZodBoolean>;
+        openGraph: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        sitemap: boolean;
+        robots: boolean;
+        openGraph: boolean;
+    }, {
+        sitemap?: boolean | undefined;
+        robots?: boolean | undefined;
+        openGraph?: boolean | undefined;
+    }>>;
+    build: z.ZodDefault<z.ZodObject<{
+        target: z.ZodDefault<z.ZodString>;
+        minify: z.ZodDefault<z.ZodBoolean>;
+        sourcemap: z.ZodDefault<z.ZodBoolean>;
+        splitting: z.ZodDefault<z.ZodBoolean>;
+        outDir: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        target: string;
+        minify: boolean;
+        sourcemap: boolean;
+        splitting: boolean;
+        outDir: string;
+    }, {
+        target?: string | undefined;
+        minify?: boolean | undefined;
+        sourcemap?: boolean | undefined;
+        splitting?: boolean | undefined;
+        outDir?: string | undefined;
+    }>>;
+    experimental: z.ZodDefault<z.ZodObject<{
+        islands: z.ZodDefault<z.ZodBoolean>;
+        streaming: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        islands: boolean;
+        streaming: boolean;
+    }, {
+        islands?: boolean | undefined;
+        streaming?: boolean | undefined;
+    }>>;
+    plugins: z.ZodDefault<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{
+        name: z.ZodString;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        name: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        name: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">>]>, "many">>;
+    appDir: z.ZodDefault<z.ZodString>;
+    publicDir: z.ZodDefault<z.ZodString>;
+    styles: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    favicon: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    app: {
+        name: string;
+        url?: string | undefined;
+    };
+    devtools: boolean;
+    server: {
+        port: number;
+        host: string;
+    };
+    routing: {
+        trailingSlash: boolean;
+    };
+    seo: {
+        sitemap: boolean;
+        robots: boolean;
+        openGraph: boolean;
+    };
+    build: {
+        target: string;
+        minify: boolean;
+        sourcemap: boolean;
+        splitting: boolean;
+        outDir: string;
+    };
+    experimental: {
+        islands: boolean;
+        streaming: boolean;
+    };
+    plugins: (string | z.objectOutputType<{
+        name: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">)[];
+    appDir: string;
+    publicDir: string;
+    styles: string[];
+    favicon: string | null;
+}, {
+    app?: {
+        url?: string | undefined;
+        name?: string | undefined;
+    } | undefined;
+    devtools?: boolean | undefined;
+    server?: {
+        port?: number | undefined;
+        host?: string | undefined;
+    } | undefined;
+    routing?: {
+        trailingSlash?: boolean | undefined;
+    } | undefined;
+    seo?: {
+        sitemap?: boolean | undefined;
+        robots?: boolean | undefined;
+        openGraph?: boolean | undefined;
+    } | undefined;
+    build?: {
+        target?: string | undefined;
+        minify?: boolean | undefined;
+        sourcemap?: boolean | undefined;
+        splitting?: boolean | undefined;
+        outDir?: string | undefined;
+    } | undefined;
+    experimental?: {
+        islands?: boolean | undefined;
+        streaming?: boolean | undefined;
+    } | undefined;
+    plugins?: (string | z.objectInputType<{
+        name: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">)[] | undefined;
+    appDir?: string | undefined;
+    publicDir?: string | undefined;
+    styles?: string[] | undefined;
+    favicon?: string | null | undefined;
+}>;
+type VelixConfig = z.infer<typeof VelixConfigSchema>;
+declare const defaultConfig: VelixConfig;
+/**
+ * Helper function to define configuration with full type support.
+ * Use this in your velix.config.ts file.
+ *
+ * @example
+ * ```ts
+ * import { defineConfig } from "velix";
+ *
+ * export default defineConfig({
+ *   app: { name: "My App" },
+ *   server: { port: 3000 },
+ *   seo: { sitemap: true }
+ * });
+ * ```
+ */
+declare function defineConfig(config: Partial<VelixConfig>): Partial<VelixConfig>;
+/**
+ * Loads and validates configuration from velix.config.ts
+ */
+declare function loadConfig(projectRoot: string): Promise<VelixConfig>;
+/**
+ * Resolves all paths in config relative to project root
+ */
+declare function resolvePaths(config: VelixConfig, projectRoot: string): VelixConfig & {
+    resolvedAppDir: string;
+    resolvedPublicDir: string;
+    resolvedOutDir: string;
+};
+
+/**
+ * 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?: unknown;
+    raw: http.IncomingMessage;
+}
+interface MiddlewareResponse {
+    status: (code: number) => MiddlewareResponse;
+    header: (name: string, value: string) => MiddlewareResponse;
+    json: (data: unknown) => 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 proxy middleware from the project root (proxy.ts or proxy.js)
+ */
+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;
+
+type ReactNode = unknown;
+type ComponentType<P = {}> = unknown;
+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;
+    middleware?: string | null;
+    isServerComponent?: boolean;
+    isClientComponent?: boolean;
+    isIsland?: boolean;
+    params?: Record<string, string>;
+}
+interface RouteTree {
+    pages: Route[];
+    api: Route[];
+    layouts: Map<string, string>;
+    tree: RouteTreeNode;
+    appRoutes: Route[];
+    rootLayout?: string;
+}
+interface RouteTreeNode {
+    children: Record<string, RouteTreeNode>;
+    routes: Route[];
+}
+interface RouteMatch {
+    route: Route;
+    params: Record<string, string>;
+}
+type Request = IncomingMessage & {
+    params?: Record<string, string>;
+    query?: Record<string, string>;
+    body?: unknown;
+    json?: () => Promise<unknown>;
+};
+type Response = ServerResponse & {
+    json?: (data: unknown) => void;
+    send?: (data: string) => void;
+    status?: (code: number) => Response;
+};
+type NextFunction = () => void | Promise<void>;
+type Middleware = (req: Request, res: Response, next: NextFunction) => void | Promise<void>;
+type ApiHandler = (req: Request, res: Response) => 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;
+}
+type InferParams<Path extends string> = Path extends `${infer _Start}/[...${infer Param}]/${infer Rest}` ? {
+    [K in Param]: string;
+} & InferParams<`/${Rest}`> : Path extends `${infer _Start}/[[...${infer Param}]]/${infer Rest}` ? {
+    [K in Param]?: string;
+} & InferParams<`/${Rest}`> : Path extends `${infer _Start}/[${infer Param}]/${infer Rest}` ? {
+    [K in Param]: string;
+} & InferParams<`/${Rest}`> : Path extends `${infer _Start}/[...${infer Param}]` ? {
+    [K in Param]: string;
+} : Path extends `${infer _Start}/[[...${infer Param}]]` ? {
+    [K in Param]?: string;
+} : Path extends `${infer _Start}/[${infer Param}]` ? {
+    [K in Param]: string;
+} : Record<string, string>;
+interface PageProps<TPath extends string = string> {
+    params: InferParams<TPath>;
+    searchParams?: Record<string, string>;
+}
+interface LayoutProps<TPath extends string = string> {
+    children: ReactNode;
+    params: InferParams<TPath>;
+}
+interface ErrorProps {
+    error: Error;
+    reset: () => void;
+}
+interface LoadingProps {
+}
+interface NotFoundProps {
+}
+type PageComponent<TPath extends string = string> = ComponentType<PageProps<TPath>>;
+type LayoutComponent<TPath extends string = string> = ComponentType<LayoutProps<TPath>>;
+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: VelixConfig) => void | Promise<void>;
+    transform?: (code: string, id: string) => string | null | Promise<string | null>;
+    buildStart?: () => void | Promise<void>;
+    buildEnd?: () => void | Promise<void>;
+}
+
+declare const RouteType: {
+    readonly PAGE: "page";
+    readonly API: "api";
+    readonly LAYOUT: "layout";
+    readonly LOADING: "loading";
+    readonly ERROR: "error";
+    readonly NOT_FOUND: "not-found";
+};
+/**
+ * Builds the complete route tree from the app/ directory
+ */
+declare function buildRouteTree(appDir: string): {
+    pages: Route[];
+    api: Route[];
+    layouts: Map<string, string>;
+    tree: RouteTreeNode;
+    appRoutes: Route[];
+    rootLayout?: string;
+};
+/**
+ * Matches URL path against routes
+ */
+declare function matchRoute(urlPath: string, routes: Route[]): {
+    params: Record<string, string>;
+    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;
+    middleware?: string | null;
+    isServerComponent?: boolean;
+    isClientComponent?: boolean;
+    isIsland?: boolean;
+} | null;
+/**
+ * Finds all layouts that apply to a route
+ */
+declare function findRouteLayouts(route: Route, layoutsMap: Map<string, string>): Array<{
+    name: string;
+    filePath: string | undefined;
+}>;
+
+/**
+ * Velix v5 Logger
+ * Minimalist, professional output inspired by modern CLIs
+ */
+declare const logger: {
+    logo(): void;
+    serverStart(config: {
+        port: number | string;
+        host: string;
+        mode: string;
+        pagesDir?: string;
+    }, 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;
+};
+
+/**
+ * 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, unknown>): 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: Array<{
+    type: string;
+    path: string;
+}>, baseUrl: string): string;
+/**
+ * Generate robots.txt content
+ */
+declare function generateRobotsTxt(baseUrl: string, options?: {
+    disallow?: string[];
+    allow?: string[];
+}): string;
+
+/**
+ * Velix v5 Plugin System
+ * Extensible hook-based plugin architecture
+ */
+declare const PluginHooks: {
+    readonly CONFIG: "config";
+    readonly SERVER_START: "server:start";
+    readonly REQUEST: "request";
+    readonly RESPONSE: "response";
+    readonly ROUTES_LOADED: "routes:loaded";
+    readonly BEFORE_RENDER: "render:before";
+    readonly AFTER_RENDER: "render:after";
+    readonly BUILD_START: "build:start";
+    readonly BUILD_END: "build:end";
+};
+type PluginHook = typeof PluginHooks[keyof typeof PluginHooks];
+interface PluginHookArgs {
+    [PluginHooks.CONFIG]: [config: VelixConfig];
+    [PluginHooks.SERVER_START]: [context: {
+        config: VelixConfig;
+        isDev: boolean;
+        projectRoot: string;
+    }, isDev: boolean];
+    [PluginHooks.REQUEST]: [req: http.IncomingMessage, res: http.ServerResponse];
+    [PluginHooks.RESPONSE]: [req: http.IncomingMessage, res: http.ServerResponse, duration: number];
+    [PluginHooks.ROUTES_LOADED]: [routes: RouteTree];
+    [PluginHooks.BEFORE_RENDER]: [html: string, context: {
+        route: Route;
+        config: VelixConfig;
+        isDev: boolean;
+    }];
+    [PluginHooks.AFTER_RENDER]: [html: string, context: {
+        route: Route;
+        config: VelixConfig;
+        isDev: boolean;
+    }];
+    [PluginHooks.BUILD_START]: [];
+    [PluginHooks.BUILD_END]: [stats: {
+        time: number;
+    }];
+}
+interface VelixPluginDefinition {
+    name: string;
+    version?: string;
+    setup?: (config: VelixConfig) => void | Promise<void>;
+    hooks?: {
+        [K in PluginHook]?: (...args: PluginHookArgs[K]) => unknown;
+    };
+    [key: string]: unknown;
+}
+declare class PluginManager {
+    private plugins;
+    private hooks;
+    /**
+     * Register a plugin
+     */
+    register(plugin: VelixPluginDefinition): void;
+    /**
+     * Run a hook with arguments
+     */
+    runHook<K extends PluginHook>(hookName: K, ...args: PluginHookArgs[K]): Promise<void>;
+    /**
+     * Run a waterfall hook — each handler transforms the first argument
+     */
+    runWaterfallHook<K extends PluginHook>(hookName: K, value: PluginHookArgs[K][0], ...args: PluginHookArgs[K] extends [unknown, ...infer Rest] ? Rest : []): Promise<PluginHookArgs[K][0]>;
+    /**
+     * Get all registered plugins
+     */
+    getPlugins(): VelixPluginDefinition[];
+    /**
+     * Check if a plugin is registered
+     */
+    hasPlugin(name: string): boolean;
+}
+declare const pluginManager: PluginManager;
+/**
+ * Load plugins from project configuration
+ */
+declare function loadPlugins(projectRoot: string, config: {
+    plugins?: unknown[];
+}): Promise<void>;
+/**
+ * Helper to define a Velix plugin with type safety.
+ *
+ * @example
+ * ```ts
+ * export default definePlugin({
+ *   name: 'my-plugin',
+ *   hooks: {
+ *     'server:start': (server) => {
+ *       console.log('Server started!');
+ *     }
+ *   }
+ * });
+ * ```
+ */
+declare function definePlugin(definition: VelixPluginDefinition): VelixPluginDefinition;
+declare const builtinPlugins: {
+    /**
+     * Security headers plugin
+     */
+    security: VelixPluginDefinition;
+    /**
+     * Request logging plugin
+     */
+    logger: VelixPluginDefinition;
+};
+
+interface TailwindPluginOptions {
+    input?: string;
+    output?: string;
+    config?: string;
+    minify?: boolean;
+}
+
+/**
+ * Velix AI Plugin - Type Definitions
+ * @module velix-plugin-ai/types
+ */
+/**
+ * Supported AI providers
+ */
+type AIProviderType = 'openai' | 'ollama' | 'anthropic';
+/**
+ * AI input configuration
+ */
+interface AIInput {
+    /** The prompt or message to send to the AI */
+    prompt: string;
+    /** System message for context */
+    system?: string;
+    /** Model to use (provider-specific) */
+    model?: string;
+    /** Temperature for randomness (0-1) */
+    temperature?: number;
+    /** Maximum tokens to generate */
+    maxTokens?: number;
+    /** Stop sequences */
+    stop?: string[];
+    /** Additional provider-specific options */
+    options?: Record<string, unknown>;
+}
+/**
+ * Chat message
+ */
+interface ChatMessage {
+    role: 'system' | 'user' | 'assistant';
+    content: string;
+}
+/**
+ * Chat input configuration
+ */
+interface ChatInput {
+    /** Array of chat messages */
+    messages: ChatMessage[];
+    /** Model to use */
+    model?: string;
+    /** Temperature for randomness (0-1) */
+    temperature?: number;
+    /** Maximum tokens to generate */
+    maxTokens?: number;
+    /** Stop sequences */
+    stop?: string[];
+    /** Additional provider-specific options */
+    options?: Record<string, unknown>;
+}
+/**
+ * AI response
+ */
+interface AIResponse {
+    /** Generated text */
+    text: string;
+    /** Provider that generated the response */
+    provider: AIProviderType;
+    /** Model used */
+    model: string;
+    /** Token usage information */
+    usage?: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+    /** Raw provider response */
+    raw?: unknown;
+}
+/**
+ * Stream chunk
+ */
+interface AIStreamChunk {
+    /** Chunk of generated text */
+    text: string;
+    /** Whether this is the final chunk */
+    done: boolean;
+    /** Provider that generated the chunk */
+    provider?: AIProviderType;
+    /** Model used */
+    model?: string;
+}
+/**
+ * Embedding input
+ */
+interface EmbedInput {
+    /** Text to embed */
+    text: string;
+    /** Model to use for embeddings */
+    model?: string;
+}
+/**
+ * Embedding response
+ */
+interface EmbedResponse {
+    /** Embedding vector */
+    embedding: number[];
+    /** Provider that generated the embedding */
+    provider: AIProviderType;
+    /** Model used */
+    model: string;
+}
+/**
+ * AI Provider interface
+ */
+interface AIProvider {
+    /** Provider name */
+    name: AIProviderType;
+    /** Generate text from a prompt */
+    generate(input: AIInput): Promise<AIResponse>;
+    /** Chat with messages */
+    chat(input: ChatInput): Promise<AIResponse>;
+    /** Stream text generation */
+    stream(input: AIInput): AsyncIterable<AIStreamChunk>;
+    /** Generate embeddings */
+    embed(input: EmbedInput): Promise<EmbedResponse>;
+}
+/**
+ * AI Plugin configuration
+ */
+interface AIPluginConfig {
+    /** Provider to use */
+    provider: AIProviderType;
+    /** API key (for cloud providers) */
+    apiKey?: string;
+    /** Base URL (for custom endpoints) */
+    baseUrl?: string;
+    /** Default model */
+    defaultModel?: string;
+    /** Default temperature */
+    defaultTemperature?: number;
+    /** Retry configuration */
+    retry?: {
+        maxRetries: number;
+        retryDelay: number;
+    };
+}
+/**
+ * AI Client interface
+ */
+interface AIClient {
+    /** Generate text from a prompt */
+    generate(input: AIInput): Promise<AIResponse>;
+    /** Chat with messages */
+    chat(input: ChatInput): Promise<AIResponse>;
+    /** Stream text generation */
+    stream(input: AIInput): AsyncIterable<AIStreamChunk>;
+    /** Generate embeddings */
+    embed(input: EmbedInput): Promise<EmbedResponse>;
+    /** Get current provider */
+    getProvider(): AIProvider;
+}
+/**
+ * Action AI configuration
+ */
+interface ActionAIConfig<TInput = unknown> {
+    /** Input schema */
+    input: TInput;
+    /** Prompt builder function */
+    prompt: (input: TInput) => string;
+    /** System message */
+    system?: string;
+    /** Model to use */
+    model?: string;
+    /** Temperature */
+    temperature?: number;
+    /** Post-processing function */
+    transform?: (response: string) => unknown;
+}
+
+/**
+ * Velix AI Plugin - Utilities
+ * @module velix-plugin-ai/utils
+ */
+/**
+ * Retry a function with exponential backoff
+ */
+declare function retry<T>(fn: () => Promise<T>, options?: {
+    maxRetries: number;
+    retryDelay: number;
+}): Promise<T>;
+/**
+ * Safe JSON parsing with fallback
+ */
+declare function safeJsonParse<T = unknown>(text: string, fallback?: T): T | null;
+/**
+ * Build a prompt from a template
+ */
+declare function buildPrompt(template: string, variables: Record<string, unknown>): string;
+/**
+ * Validate API key
+ */
+declare function validateApiKey(apiKey: string | undefined, provider: string): void;
+/**
+ * Validate input
+ */
+declare function validateInput(input: Record<string, unknown>, requiredFields: string[]): void;
+/**
+ * Create a streaming text decoder
+ */
+declare function createStreamDecoder(): (chunk: Uint8Array) => string;
+/**
+ * Parse SSE (Server-Sent Events) data
+ */
+declare function parseSSE(line: string): unknown;
+/**
+ * Sanitize input text
+ */
+declare function sanitizeInput(text: string): string;
+/**
+ * Count tokens (rough estimation)
+ */
+declare function estimateTokens(text: string): number;
+/**
+ * Truncate text to max tokens
+ */
+declare function truncateToTokens(text: string, maxTokens: number): string;
+
+/**
+ * Velix AI Plugin - OpenAI Provider
+ * @module velix-plugin-ai/providers/openai
+ */
+
+interface OpenAIConfig {
+    apiKey: string;
+    baseUrl?: string;
+    defaultModel?: string;
+    organization?: string;
+    retry?: {
+        maxRetries: number;
+        retryDelay: number;
+    };
+}
+declare class OpenAIProvider implements AIProvider {
+    name: "openai";
+    private apiKey;
+    private baseUrl;
+    private defaultModel;
+    private organization?;
+    private retryConfig;
+    constructor(config: OpenAIConfig);
+    generate(input: AIInput): Promise<AIResponse>;
+    chat(input: ChatInput): Promise<AIResponse>;
+    stream(input: AIInput): AsyncIterable<AIStreamChunk>;
+    embed(input: EmbedInput): Promise<EmbedResponse>;
+    private getHeaders;
+}
+
+/**
+ * Velix AI Plugin - Ollama Provider
+ * @module velix-plugin-ai/providers/ollama
+ */
+
+interface OllamaConfig {
+    baseUrl?: string;
+    defaultModel?: string;
+    retry?: {
+        maxRetries: number;
+        retryDelay: number;
+    };
+}
+declare class OllamaProvider implements AIProvider {
+    name: "ollama";
+    private baseUrl;
+    private defaultModel;
+    private retryConfig;
+    constructor(config?: OllamaConfig);
+    generate(input: AIInput): Promise<AIResponse>;
+    chat(input: ChatInput): Promise<AIResponse>;
+    stream(input: AIInput): AsyncIterable<AIStreamChunk>;
+    embed(input: EmbedInput): Promise<EmbedResponse>;
+}
+
+/**
+ * Velix AI Plugin - AI Client
+ * @module velix-plugin-ai/client
+ */
+
+/**
+ * Create an AI client
+ */
+declare function createAIClient(config: AIPluginConfig): AIClient;
+
+/**
+ * Velix AI Plugin v1
+ * @module velix-plugin-ai
+ */
+
+/**
+ * Get AI client in server actions
+ */
+declare function useAI(): AIClient;
+/**
+ * Create an AI-powered server action
+ *
+ * @example
+ * ```ts
+ * export const summarize = createAIAction({
+ *   input: { text: 'string' },
+ *   prompt: ({ text }) => `Summarize this text: ${text}`,
+ *   system: 'You are a helpful assistant that summarizes text concisely.'
+ * });
+ * ```
+ */
+declare function createAIAction<TInput = unknown, TOutput = string>(config: {
+    input: TInput;
+    prompt: (input: TInput) => string;
+    system?: string;
+    model?: string;
+    temperature?: number;
+    transform?: (response: string) => TOutput;
+}): (input: TInput) => Promise<TOutput>;
+
+/**
+ * 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: unknown[]) => unknown>(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<T>(): {
+    promise: Promise<T>;
+    resolve: (value: T | PromiseLike<T>) => void;
+    reject: (reason?: unknown) => void;
+};
+/**
+ * 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 — Advanced Cache (VelixCache)
+ *
+ * Production-grade caching with:
+ * - LRU eviction (configurable maxSize)
+ * - TTL-based expiration
+ * - Stale-while-revalidate (SWR) window
+ * - Tag-based invalidation
+ * - Type-safe generics
+ */
+type RevalidationType = 'path' | 'tag' | 'layout';
+interface CacheOptions {
+    /** Time-to-live in milliseconds */
+    ttl?: number;
+    /** Stale-while-revalidate window in milliseconds (after TTL expires) */
+    swr?: number;
+    /** Tags for group invalidation */
+    tags?: string[];
+}
+interface VelixCacheConfig {
+    /** Maximum number of entries (default: 1000) */
+    maxSize?: number;
+    /** Default TTL in ms (default: 60_000 — 1 minute) */
+    defaultTtl?: number;
+    /** Default SWR window in ms (default: 10_000 — 10 seconds) */
+    defaultSwr?: number;
+}
+declare class VelixCache {
+    private readonly maxSize;
+    private readonly defaultTtl;
+    private readonly defaultSwr;
+    private readonly store;
+    private readonly tagIndex;
+    private readonly head;
+    private readonly tail;
+    constructor(config?: VelixCacheConfig);
+    /** Current number of entries */
+    get size(): number;
+    /**
+     * Store a value with optional TTL, SWR, and tags.
+     */
+    set<T>(key: string, value: T, options?: CacheOptions): void;
+    /**
+     * Get a cached value. Returns `null` if not found or expired beyond SWR window.
+     *
+     * @returns `{ value, stale }` — `stale` is true when the entry is past TTL but within SWR window.
+     */
+    get<T>(key: string): {
+        value: T;
+        stale: boolean;
+    } | null;
+    /**
+     * Simple get that returns only the value (ignoring staleness).
+     * Returns `null` if not found or expired.
+     */
+    getValue<T>(key: string): T | null;
+    /** Check whether a key exists and is not expired */
+    has(key: string): boolean;
+    /** Remove a specific key */
+    delete(key: string): boolean;
+    /** Invalidate a specific path/key */
+    revalidatePath(path: string): void;
+    /** Invalidate all entries associated with a tag */
+    revalidateTag(tag: string): void;
+    /** Clear all entries */
+    invalidateAll(): void;
+    /** Get cache stats for debugging/monitoring */
+    stats(): {
+        size: number;
+        maxSize: number;
+        tags: number;
+    };
+    private createSentinel;
+    private addToHead;
+    private removeFromList;
+    private moveToHead;
+    private evictLRU;
+    private removeEntry;
+}
+declare const cacheManager: VelixCache;
+/**
+ * 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>;
+
+export { type AIClient, type AIInput, type AIPluginConfig, type AIProvider, type AIProviderType, type AIResponse, type AIStreamChunk, type ActionAIConfig, type ActionState, type Alternates, type ApiHandler, type Author, type BuildOptions, type BuildResult, type CacheOptions, type ChatInput, type ChatMessage, type EmbedInput, type EmbedResponse, type ErrorComponent, type ErrorProps, type FormatDetection, type IconDescriptor, type Icons, type IslandConfig, type IslandManifest, type LayoutComponent, type LayoutProps, type LoadingComponent, type LoadingProps, type Metadata, type Middleware, type MiddlewareFunction, type MiddlewareRequest, type MiddlewareResponse, type MiddlewareResult, type NextFunction, type NotFoundComponent, type NotFoundProps, type OGImage, type OGVideo, OllamaProvider, OpenAIProvider, type OpenGraph, type PageComponent, type PageProps, type PluginHook, type PluginHookArgs, PluginHooks, PluginManager, type RevalidationType, type Robots, type Route, type RouteMatch, type RouteTree, RouteType, type ServerAction, type StaticPath, type StaticProps, type TailwindPluginOptions, type ThemeColor, type Twitter, type TwitterImage, type TypedActionResult, VelixCache, type VelixConfig, VelixConfigSchema, type VelixPlugin, type VelixPluginDefinition, type Verification, type Viewport, buildPrompt, buildRouteTree, builtinPlugins, cacheManager, cleanDir, composeMiddleware, copyDir, createAIAction, createAIClient, createDeferred, createStreamDecoder, debounce, defaultConfig, defineConfig, definePlugin, ensureDir, escapeHtml, estimateTokens, findFiles, findRouteLayouts, formatBytes, formatTime, generateHash, generateJsonLd, generateMetadataTags, generateRobotsTxt, generateSitemap, isClientComponent, isIsland, isServerComponent, jsonLd, loadConfig, loadMiddleware, loadPlugins, logger, matchRoute, mergeMetadata, middlewares, parseSSE, pluginManager, resolvePaths, retry, revalidatePath, revalidateTag, runMiddleware, safeJsonParse, sanitizeInput, sleep, truncateToTokens, unstable_cache, useAI, validateApiKey, validateInput };