elit 3.0.9 → 3.1.0

package/dist/style.d.mts

@@ -0,0 +1,159 @@
+/**
+ * Elit - CreateStyle CSS Generation System
+ */
+interface CSSVariable {
+    name: string;
+    value: string;
+    toString(): string;
+}
+interface CSSRule {
+    selector: string;
+    styles: Record<string, string | number>;
+    nested?: CSSRule[];
+    type: 'tag' | 'class' | 'id' | 'pseudo-class' | 'pseudo-element' | 'name' | 'custom' | 'media' | 'attribute';
+}
+interface MediaRule {
+    type: string;
+    condition: string;
+    rules: CSSRule[];
+}
+interface KeyframeStep {
+    step: string | number;
+    styles: Record<string, string | number>;
+}
+interface Keyframes {
+    name: string;
+    steps: KeyframeStep[];
+}
+interface FontFace {
+    fontFamily: string;
+    src: string;
+    fontWeight?: string | number;
+    fontStyle?: string;
+    fontDisplay?: string;
+    unicodeRange?: string;
+}
+interface ContainerRule {
+    name?: string;
+    condition: string;
+    rules: CSSRule[];
+}
+interface SupportsRule {
+    condition: string;
+    rules: CSSRule[];
+}
+interface LayerRule {
+    name: string;
+    rules: CSSRule[];
+}
+declare class CreateStyle {
+    private variables;
+    private rules;
+    private mediaRules;
+    private keyframes;
+    private fontFaces;
+    private imports;
+    private containerRules;
+    private supportsRules;
+    private layerRules;
+    private _layerOrder;
+    addVar(name: string, value: string): CSSVariable;
+    var(variable: CSSVariable | string, fallback?: string): string;
+    addTag(tag: string, styles: Record<string, string | number>): CSSRule;
+    addClass(name: string, styles: Record<string, string | number>): CSSRule;
+    addId(name: string, styles: Record<string, string | number>): CSSRule;
+    addPseudoClass(pseudo: string, styles: Record<string, string | number>, baseSelector?: string): CSSRule;
+    addPseudoElement(pseudo: string, styles: Record<string, string | number>, baseSelector?: string): CSSRule;
+    addAttribute(attr: string, styles: Record<string, string | number>, baseSelector?: string): CSSRule;
+    attrEquals(attr: string, value: string, styles: Record<string, string | number>, baseSelector?: string): CSSRule;
+    attrContainsWord(attr: string, value: string, styles: Record<string, string | number>, baseSelector?: string): CSSRule;
+    attrStartsWith(attr: string, value: string, styles: Record<string, string | number>, baseSelector?: string): CSSRule;
+    attrEndsWith(attr: string, value: string, styles: Record<string, string | number>, baseSelector?: string): CSSRule;
+    attrContains(attr: string, value: string, styles: Record<string, string | number>, baseSelector?: string): CSSRule;
+    descendant(ancestor: string, descendant: string, styles: Record<string, string | number>): CSSRule;
+    child(parent: string, childSel: string, styles: Record<string, string | number>): CSSRule;
+    adjacentSibling(element: string, sibling: string, styles: Record<string, string | number>): CSSRule;
+    generalSibling(element: string, sibling: string, styles: Record<string, string | number>): CSSRule;
+    multiple(selectors: string[], styles: Record<string, string | number>): CSSRule;
+    addName(name: string, styles: Record<string, string | number>): CSSRule;
+    nesting(parentRule: CSSRule, ...childRules: CSSRule[]): CSSRule;
+    keyframe(name: string, steps: Record<string | number, Record<string, string | number>>): Keyframes;
+    keyframeFromTo(name: string, from: Record<string, string | number>, to: Record<string, string | number>): Keyframes;
+    fontFace(options: FontFace): FontFace;
+    import(url: string, mediaQuery?: string): string;
+    media(type: string, condition: string, rules: Record<string, Record<string, string | number>>): MediaRule;
+    mediaScreen(condition: string, rules: Record<string, Record<string, string | number>>): MediaRule;
+    mediaPrint(rules: Record<string, Record<string, string | number>>): MediaRule;
+    mediaMinWidth(minWidth: string, rules: Record<string, Record<string, string | number>>): MediaRule;
+    mediaMaxWidth(maxWidth: string, rules: Record<string, Record<string, string | number>>): MediaRule;
+    mediaDark(rules: Record<string, Record<string, string | number>>): MediaRule;
+    mediaLight(rules: Record<string, Record<string, string | number>>): MediaRule;
+    mediaReducedMotion(rules: Record<string, Record<string, string | number>>): MediaRule;
+    container(condition: string, rules: Record<string, Record<string, string | number>>, name?: string): ContainerRule;
+    addContainer(name: string, styles: Record<string, string | number>): CSSRule;
+    supports(condition: string, rules: Record<string, Record<string, string | number>>): SupportsRule;
+    layerOrder(...layers: string[]): void;
+    layer(name: string, rules: Record<string, Record<string, string | number>>): LayerRule;
+    add(rules: Record<string, Record<string, string | number>>): CSSRule[];
+    important(value: string | number): string;
+    private toKebabCase;
+    private createAndAddRule;
+    private rulesToCSSRules;
+    private renderRulesWithIndent;
+    private stylesToString;
+    private renderRule;
+    private renderMediaRule;
+    private renderKeyframes;
+    private renderFontFace;
+    private renderContainerRule;
+    private renderSupportsRule;
+    private renderLayerRule;
+    render(...additionalRules: (CSSRule | CSSRule[] | MediaRule | Keyframes | ContainerRule | SupportsRule | LayerRule | undefined | null)[]): string;
+    inject(styleId?: string): HTMLStyleElement;
+    clear(): void;
+}
+declare const styles: CreateStyle;
+declare const addVar: (name: string, value: string) => CSSVariable;
+declare const getVar: (variable: CSSVariable | string, fallback?: string) => string;
+declare const addTag: (tag: string, styles: Record<string, string | number>) => CSSRule;
+declare const addClass: (name: string, styles: Record<string, string | number>) => CSSRule;
+declare const addId: (name: string, styles: Record<string, string | number>) => CSSRule;
+declare const addPseudoClass: (pseudo: string, styles: Record<string, string | number>, baseSelector?: string) => CSSRule;
+declare const addPseudoElement: (pseudo: string, styles: Record<string, string | number>, baseSelector?: string) => CSSRule;
+declare const addAttribute: (attr: string, styles: Record<string, string | number>, baseSelector?: string) => CSSRule;
+declare const attrEquals: (attr: string, value: string, styles: Record<string, string | number>, baseSelector?: string) => CSSRule;
+declare const attrContainsWord: (attr: string, value: string, styles: Record<string, string | number>, baseSelector?: string) => CSSRule;
+declare const attrStartsWith: (attr: string, value: string, styles: Record<string, string | number>, baseSelector?: string) => CSSRule;
+declare const attrEndsWith: (attr: string, value: string, styles: Record<string, string | number>, baseSelector?: string) => CSSRule;
+declare const attrContains: (attr: string, value: string, styles: Record<string, string | number>, baseSelector?: string) => CSSRule;
+declare const descendant: (ancestor: string, descendant: string, styles: Record<string, string | number>) => CSSRule;
+declare const childStyle: (parent: string, childSel: string, styles: Record<string, string | number>) => CSSRule;
+declare const adjacentSibling: (element: string, sibling: string, styles: Record<string, string | number>) => CSSRule;
+declare const generalSibling: (element: string, sibling: string, styles: Record<string, string | number>) => CSSRule;
+declare const multipleStyle: (selectors: string[], styles: Record<string, string | number>) => CSSRule;
+declare const addName: (name: string, styles: Record<string, string | number>) => CSSRule;
+declare const nesting: (parentRule: CSSRule, ...childRules: CSSRule[]) => CSSRule;
+declare const keyframe: (name: string, steps: Record<string | number, Record<string, string | number>>) => Keyframes;
+declare const keyframeFromTo: (name: string, from: Record<string, string | number>, to: Record<string, string | number>) => Keyframes;
+declare const fontFace: (options: FontFace) => FontFace;
+declare const importStyle: (url: string, mediaQuery?: string) => string;
+declare const mediaStyle: (type: string, condition: string, rules: Record<string, Record<string, string | number>>) => MediaRule;
+declare const mediaScreen: (condition: string, rules: Record<string, Record<string, string | number>>) => MediaRule;
+declare const mediaPrint: (rules: Record<string, Record<string, string | number>>) => MediaRule;
+declare const mediaMinWidth: (minWidth: string, rules: Record<string, Record<string, string | number>>) => MediaRule;
+declare const mediaMaxWidth: (maxWidth: string, rules: Record<string, Record<string, string | number>>) => MediaRule;
+declare const mediaDark: (rules: Record<string, Record<string, string | number>>) => MediaRule;
+declare const mediaLight: (rules: Record<string, Record<string, string | number>>) => MediaRule;
+declare const mediaReducedMotion: (rules: Record<string, Record<string, string | number>>) => MediaRule;
+declare const container: (condition: string, rules: Record<string, Record<string, string | number>>, name?: string) => ContainerRule;
+declare const addContainer: (name: string, styles: Record<string, string | number>) => CSSRule;
+declare const supportsStyle: (condition: string, rules: Record<string, Record<string, string | number>>) => SupportsRule;
+declare const layerOrder: (...layers: string[]) => void;
+declare const layer: (name: string, rules: Record<string, Record<string, string | number>>) => LayerRule;
+declare const addStyle: (rules: Record<string, Record<string, string | number>>) => CSSRule[];
+declare const important: (value: string | number) => string;
+declare const renderStyle: (...additionalRules: (CSSRule | CSSRule[] | MediaRule | Keyframes | ContainerRule | SupportsRule | LayerRule | undefined | null)[]) => string;
+declare const injectStyle: (styleId?: string) => HTMLStyleElement;
+declare const clearStyle: () => void;
+
+export { type CSSRule, type CSSVariable, type ContainerRule, CreateStyle, type FontFace, type KeyframeStep, type Keyframes, type LayerRule, type MediaRule, type SupportsRule, addAttribute, addClass, addContainer, addId, addName, addPseudoClass, addPseudoElement, addStyle, addTag, addVar, adjacentSibling, attrContains, attrContainsWord, attrEndsWith, attrEquals, attrStartsWith, childStyle, clearStyle, container, styles as default, descendant, fontFace, generalSibling, getVar, importStyle, important, injectStyle, keyframe, keyframeFromTo, layer, layerOrder, mediaDark, mediaLight, mediaMaxWidth, mediaMinWidth, mediaPrint, mediaReducedMotion, mediaScreen, mediaStyle, multipleStyle, nesting, renderStyle, styles, supportsStyle };

package/dist/types.d.mts

@@ -0,0 +1,446 @@
+import { EventEmitter } from 'node:events';
+import { EventEmitter as EventEmitter$1 } from 'events';
+import { Server } from 'http';
+import { WebSocketServer } from 'ws';
+
+/**
+ * HTTP module with unified API across runtimes
+ * Ultra-optimized for maximum performance across Node.js, Bun, and Deno
+ *
+ * Performance optimizations:
+ * - Bun fast path: Zero class instantiation (object literals only)
+ * - Eliminated EventEmitter overhead for Bun/Deno
+ * - Zero-copy headers conversion
+ * - Inline response creation
+ * - Reduced object allocations
+ * - Direct closure capture (no resolver indirection)
+ */
+
+/**
+ * HTTP Headers type
+ */
+type IncomingHttpHeaders = Record<string, string | string[] | undefined>;
+type OutgoingHttpHeaders = Record<string, string | string[] | number>;
+/**
+ * IncomingMessage - Ultra-optimized for zero-copy operations
+ */
+declare class IncomingMessage extends EventEmitter {
+    method: string;
+    url: string;
+    headers: IncomingHttpHeaders;
+    statusCode?: number;
+    statusMessage?: string;
+    httpVersion: string;
+    rawHeaders: string[];
+    socket: any;
+    private _req;
+    constructor(req: any);
+    text(): Promise<string>;
+    json(): Promise<any>;
+}
+/**
+ * ServerResponse - Ultra-optimized write operations
+ */
+declare class ServerResponse extends EventEmitter {
+    statusCode: number;
+    statusMessage: string;
+    headersSent: boolean;
+    private _headers;
+    private _body;
+    private _resolve?;
+    private _finished;
+    private _nodeRes?;
+    constructor(_req?: IncomingMessage, nodeRes?: any);
+    setHeader(name: string, value: string | string[] | number): this;
+    getHeader(name: string): string | string[] | number | undefined;
+    getHeaders(): OutgoingHttpHeaders;
+    getHeaderNames(): string[];
+    hasHeader(name: string): boolean;
+    removeHeader(name: string): void;
+    writeHead(statusCode: number, statusMessage?: string | OutgoingHttpHeaders, headers?: OutgoingHttpHeaders): this;
+    write(chunk: any, encoding?: BufferEncoding | (() => void), callback?: () => void): boolean;
+    end(chunk?: any, encoding?: BufferEncoding | (() => void), callback?: () => void): this;
+    _setResolver(resolve: (response: Response) => void): void;
+}
+
+/**
+ * WebSocket module with unified API across runtimes
+ * Pure implementation without external dependencies
+ * - Node.js: uses native 'ws' module (built-in WebSocket implementation)
+ * - Bun: uses native WebSocket
+ * - Deno: uses native WebSocket
+ */
+
+/**
+ * WebSocket ready state
+ */
+declare enum ReadyState {
+    CONNECTING = 0,
+    OPEN = 1,
+    CLOSING = 2,
+    CLOSED = 3
+}
+/**
+ * WebSocket data types
+ */
+type Data = string | Buffer | ArrayBuffer | Buffer[];
+/**
+ * WebSocket send options
+ */
+interface SendOptions {
+    binary?: boolean;
+    compress?: boolean;
+    fin?: boolean;
+    mask?: boolean;
+}
+/**
+ * WebSocket class - Pure implementation
+ */
+declare class WebSocket extends EventEmitter$1 {
+    readyState: ReadyState;
+    url: string;
+    protocol: string;
+    extensions: string;
+    binaryType: 'nodebuffer' | 'arraybuffer' | 'fragments';
+    /** @internal */
+    _socket: any;
+    constructor(address: string | URL, protocols?: string | string[], _options?: any);
+    private _setupNativeSocket;
+    /**
+     * Send data through WebSocket
+     */
+    send(data: Data, options?: SendOptions | ((err?: Error) => void), callback?: (err?: Error) => void): void;
+    /**
+     * Close the WebSocket connection
+     */
+    close(code?: number, reason?: string | Buffer): void;
+    /**
+     * Pause the socket (no-op for native WebSocket)
+     */
+    pause(): void;
+    /**
+     * Resume the socket (no-op for native WebSocket)
+     */
+    resume(): void;
+    /**
+     * Send a ping frame (no-op for native WebSocket)
+     */
+    ping(_data?: Data, _mask?: boolean, callback?: (err?: Error) => void): void;
+    /**
+     * Send a pong frame (no-op for native WebSocket)
+     */
+    pong(_data?: Data, _mask?: boolean, callback?: (err?: Error) => void): void;
+    /**
+     * Terminate the connection
+     */
+    terminate(): void;
+    /**
+     * Get buffered amount
+     */
+    get bufferedAmount(): number;
+}
+
+/**
+ * Development server with HMR support
+ * Cross-runtime transpilation support
+ * - Node.js: uses esbuild
+ * - Bun: uses Bun.Transpiler
+ * - Deno: uses Deno.emit
+ */
+
+interface ServerRouteContext {
+    req: IncomingMessage;
+    res: ServerResponse;
+    params: Record<string, string>;
+    query: Record<string, string>;
+    body: any;
+    headers: Record<string, string | string[] | undefined>;
+}
+type ServerRouteHandler = (ctx: ServerRouteContext) => void | Promise<void>;
+type Middleware = (ctx: ServerRouteContext, next: () => Promise<void>) => void | Promise<void>;
+declare class ServerRouter {
+    private routes;
+    private middlewares;
+    use(middleware: Middleware): this;
+    get: (path: string, handler: ServerRouteHandler) => this;
+    post: (path: string, handler: ServerRouteHandler) => this;
+    put: (path: string, handler: ServerRouteHandler) => this;
+    delete: (path: string, handler: ServerRouteHandler) => this;
+    patch: (path: string, handler: ServerRouteHandler) => this;
+    options: (path: string, handler: ServerRouteHandler) => this;
+    private addRoute;
+    private pathToRegex;
+    private parseQuery;
+    private parseBody;
+    handle(req: IncomingMessage, res: ServerResponse): Promise<boolean>;
+}
+type StateChangeHandler<T = any> = (value: T, oldValue: T) => void;
+interface SharedStateOptions<T = any> {
+    initial: T;
+    persist?: boolean;
+    validate?: (value: T) => boolean;
+}
+declare class SharedState<T = any> {
+    readonly key: string;
+    private _value;
+    private listeners;
+    private changeHandlers;
+    private options;
+    constructor(key: string, options: SharedStateOptions<T>);
+    get value(): T;
+    set value(newValue: T);
+    update(updater: (current: T) => T): void;
+    subscribe(ws: WebSocket): void;
+    unsubscribe(ws: WebSocket): void;
+    onChange(handler: StateChangeHandler<T>): () => void;
+    private broadcast;
+    private sendTo;
+    get subscriberCount(): number;
+    clear(): void;
+}
+declare class StateManager$1 {
+    private states;
+    create<T>(key: string, options: SharedStateOptions<T>): SharedState<T>;
+    get<T>(key: string): SharedState<T> | undefined;
+    has(key: string): boolean;
+    delete(key: string): boolean;
+    subscribe(key: string, ws: WebSocket): void;
+    unsubscribe(key: string, ws: WebSocket): void;
+    unsubscribeAll(ws: WebSocket): void;
+    handleStateChange(key: string, value: any): void;
+    keys(): string[];
+    clear(): void;
+}
+
+/**
+ * Elit - Types and Interfaces
+ */
+interface VNode {
+    tagName: string;
+    props: Props;
+    children: Children;
+}
+type Child = VNode | string | number | boolean | null | undefined;
+type Children = Child[];
+interface Props {
+    [key: string]: any;
+    className?: string | string[];
+    class?: string | string[];
+    style?: Partial<CSSStyleDeclaration> | string;
+    dangerouslySetInnerHTML?: {
+        __html: string;
+    };
+    ref?: RefCallback | RefObject;
+    onClick?: (event: MouseEvent) => void;
+    onChange?: (event: Event) => void;
+    onInput?: (event: Event) => void;
+    onSubmit?: (event: Event) => void;
+    value?: string | number;
+    checked?: boolean;
+}
+type RefCallback = (element: HTMLElement | SVGElement) => void;
+interface RefObject {
+    current: HTMLElement | SVGElement | null;
+}
+interface State<T> {
+    value: T;
+    subscribe(fn: (value: T) => void): () => void;
+    destroy(): void;
+}
+interface StateOptions {
+    throttle?: number;
+    deep?: boolean;
+}
+interface VirtualListController {
+    render: () => void;
+    destroy: () => void;
+}
+interface JsonNode {
+    tag: string;
+    attributes?: Record<string, any>;
+    children?: JsonNode | JsonNode[] | string | number | boolean | null;
+}
+type VNodeJson = {
+    tagName: string;
+    props?: Record<string, any>;
+    children?: (VNodeJson | string | number | boolean | null)[];
+} | string | number | boolean | null;
+type ElementFactory = {
+    (...children: Child[]): VNode;
+    (props: Props | null, ...children: Child[]): VNode;
+};
+
+type Router = ServerRouter;
+type StateManager = StateManager$1;
+interface ClientConfig {
+    /** Root directory to serve files from */
+    root: string;
+    /** Base path for the client application (e.g., '/app1', '/app2') */
+    basePath: string;
+    /** Custom index file path (relative to root, e.g., './public/index.html') */
+    index?: string;
+    /** SSR render function - returns HTML VNode or string */
+    ssr?: () => Child | string;
+    /** Watch patterns for file changes */
+    watch?: string[];
+    /** Ignore patterns for file watching */
+    ignore?: string[];
+    /** Proxy configuration specific to this client */
+    proxy?: ProxyConfig[];
+    /** Worker scripts specific to this client */
+    worker?: WorkerConfig[];
+    /** API router for REST endpoints specific to this client */
+    api?: Router;
+    /** Server mode: 'dev' uses source files, 'preview' uses built files (default: 'dev') */
+    mode?: 'dev' | 'preview';
+}
+interface ProxyConfig {
+    /** Path prefix to match for proxying (e.g., '/api', '/graphql') */
+    context: string;
+    /** Target URL to proxy to (e.g., 'http://localhost:8080') */
+    target: string;
+    /** Change the origin of the host header to the target URL */
+    changeOrigin?: boolean;
+    /** Rewrite path before sending to target */
+    pathRewrite?: Record<string, string>;
+    /** Additional headers to add to the proxied request */
+    headers?: Record<string, string>;
+    /** Enable WebSocket proxying */
+    ws?: boolean;
+}
+interface WorkerConfig {
+    /** Worker script path relative to root directory */
+    path: string;
+    /** Worker name/identifier (optional, defaults to filename) */
+    name?: string;
+    /** Worker type: 'module' (ESM) or 'classic' (default: 'module') */
+    type?: 'module' | 'classic';
+}
+interface DevServerOptions {
+    /** Port to run the server on (default: 3000) */
+    port?: number;
+    /** Host to bind to (default: 'localhost') */
+    host?: string;
+    /** Root directory to serve files from */
+    root?: string;
+    /** Base path for the client application (e.g., '/app1', '/app2') */
+    basePath?: string;
+    /** Custom index file path (relative to root, e.g., './public/index.html') */
+    index?: string;
+    /** Array of client configurations - allows multiple clients on same port */
+    clients?: ClientConfig[];
+    /** Enable HTTPS (default: false) */
+    https?: boolean;
+    /** Open browser automatically (default: true) */
+    open?: boolean;
+    /** Watch patterns for file changes */
+    watch?: string[];
+    /** Ignore patterns for file watcher */
+    ignore?: string[];
+    /** Global worker scripts (applies to all clients) */
+    worker?: WorkerConfig[];
+    /** Enable logging (default: true) */
+    logging?: boolean;
+    /** API router for REST endpoints */
+    api?: Router;
+    /** SSR render function - returns HTML VNode or string */
+    ssr?: () => Child | string;
+    /** Proxy configuration for API requests */
+    proxy?: ProxyConfig[];
+    /** Server mode: 'dev' uses source files, 'preview' uses built files (default: 'dev') */
+    mode?: 'dev' | 'preview';
+}
+interface DevServer {
+    /** HTTP server instance */
+    server: Server;
+    /** WebSocket server for HMR */
+    wss: WebSocketServer;
+    /** Server URL */
+    url: string;
+    /** Shared state manager */
+    state: StateManager;
+    /** Close the server */
+    close: () => Promise<void>;
+}
+interface HMRMessage {
+    type: 'update' | 'reload' | 'error' | 'connected';
+    path?: string;
+    timestamp?: number;
+    error?: string;
+}
+interface BuildOptions {
+    /** Entry file to build */
+    entry: string;
+    /** Output directory */
+    outDir?: string;
+    /** Output filename */
+    outFile?: string;
+    /** Enable minification */
+    minify?: boolean;
+    /** Generate sourcemap */
+    sourcemap?: boolean;
+    /** Target environment */
+    target?: 'es2015' | 'es2016' | 'es2017' | 'es2018' | 'es2019' | 'es2020' | 'es2021' | 'es2022' | 'esnext';
+    /** Output format */
+    format?: 'esm' | 'cjs' | 'iife';
+    /** Global name for IIFE format */
+    globalName?: string;
+    /** Target platform */
+    platform?: 'browser' | 'node' | 'neutral';
+    /** Base path for the application (injected into HTML) */
+    basePath?: string;
+    /** External dependencies (not bundled) */
+    external?: string[];
+    /** Enable tree shaking */
+    treeshake?: boolean;
+    /** Enable logging */
+    logging?: boolean;
+    /** Environment variables to inject (prefix with VITE_ for client access) */
+    env?: Record<string, string>;
+    /** Copy static files after build */
+    copy?: Array<{
+        from: string;
+        to: string;
+        transform?: (content: string, config: BuildOptions) => string;
+    }>;
+    /** Post-build hook */
+    onBuildEnd?: (result: BuildResult) => void | Promise<void>;
+}
+interface BuildResult {
+    /** Output file path */
+    outputPath: string;
+    /** Build time in milliseconds */
+    buildTime: number;
+    /** Output file size in bytes */
+    size: number;
+}
+interface PreviewOptions {
+    /** Port to run the preview server on (default: 4173) */
+    port?: number;
+    /** Host to bind to (default: 'localhost') */
+    host?: string;
+    /** Root directory to serve files from (default: dist or build.outDir) */
+    root?: string;
+    /** Base path for the application (e.g., '/app') */
+    basePath?: string;
+    /** Custom index file path (relative to root, e.g., './public/index.html') */
+    index?: string;
+    /** Array of client configurations - allows multiple clients on same port */
+    clients?: ClientConfig[];
+    /** Enable HTTPS (default: false) */
+    https?: boolean;
+    /** Open browser automatically (default: true) */
+    open?: boolean;
+    /** Enable logging (default: true) */
+    logging?: boolean;
+    /** API router for REST endpoints */
+    api?: Router;
+    /** SSR render function - returns HTML VNode or string */
+    ssr?: () => Child | string;
+    /** Proxy configuration for API requests */
+    proxy?: ProxyConfig[];
+    /** Global worker scripts (applies to all clients) */
+    worker?: WorkerConfig[];
+}
+
+export type { BuildOptions, BuildResult, Child, Children, ClientConfig, DevServer, DevServerOptions, ElementFactory, HMRMessage, JsonNode, PreviewOptions, Props, ProxyConfig, RefCallback, RefObject, Router, State, StateManager, StateOptions, VNode, VNodeJson, VirtualListController, WorkerConfig };