blaizejs 0.2.0 → 0.2.3

package/dist/index.d.ts

@@ -1,16 +1,18 @@
-import * as _blaizejs_types from '@blaizejs/types';
-import { MiddlewareFunction, MiddlewareOptions, Middleware, Server, PluginHooks, PluginFactory, CreateDeleteRoute, CreateGetRoute, CreateHeadRoute, CreateOptionsRoute, CreatePatchRoute, CreatePostRoute, CreatePutRoute, ServerOptionsInput } from '@blaizejs/types';
-export { BuildRoutesRegistry } from '@blaizejs/types';
+import http, { IncomingMessage, ServerResponse } from 'node:http';
+import http2, { Http2ServerRequest, Http2ServerResponse } from 'node:http2';
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { z } from 'zod';
+import { EventEmitter } from 'node:events';
 
 /**
- * Create a middleware
+ * Compose multiple middleware functions into a single middleware function
  */
-declare function create$2(handlerOrOptions: MiddlewareFunction | MiddlewareOptions): Middleware;
+declare function compose(middlewareStack: Middleware[]): MiddlewareFunction;
 
 /**
- * Compose multiple middleware functions into a single middleware function
+ * Create a middleware
  */
-declare function compose(middlewareStack: Middleware[]): MiddlewareFunction;
+declare function create$2(handlerOrOptions: MiddlewareFunction | MiddlewareOptions): Middleware;
 
 /**
  * Create a plugin with the given name, version, and setup function
@@ -51,18 +53,725 @@ declare const createOptionsRoute: CreateOptionsRoute;
  */
 declare function create(options?: ServerOptionsInput): Server;
 
+/**
+ * Unified request type supporting both HTTP/1.1 and HTTP/2
+ */
+type UnifiedRequest = IncomingMessage | Http2ServerRequest;
+/**
+ * Unified response type supporting both HTTP/1.1 and HTTP/2
+ */
+type UnifiedResponse = ServerResponse | Http2ServerResponse;
+/**
+ * Request parameters extracted from URL path
+ */
+interface RequestParams {
+    [key: string]: string;
+}
+/**
+ * Query parameters from URL
+ */
+interface QueryParams {
+    [key: string]: string | string[] | undefined;
+}
+/**
+ * Options for streaming responses
+ */
+interface StreamOptions {
+    contentType?: string;
+    status?: number;
+    headers?: Record<string, string>;
+}
+/**
+ * State container for storing request-scoped data
+ * Allows for proper typing with generics
+ */
+interface State {
+    [key: string]: unknown;
+}
+interface ContextResponse<S extends State = State> {
+    raw: UnifiedResponse;
+    sent: boolean;
+    status: (code: number) => ContextResponse<S>;
+    header: (name: string, value: string) => ContextResponse<S>;
+    headers: (headers: Record<string, string>) => ContextResponse<S>;
+    type: (contentType: string) => ContextResponse<S>;
+    json: (body: unknown, status?: number) => void;
+    text: (body: string, status?: number) => void;
+    html: (body: string, status?: number) => void;
+    redirect: (url: string, status?: number) => void;
+    stream: (readable: NodeJS.ReadableStream, options?: StreamOptions) => void;
+}
+interface ContextRequest<TBody = unknown> {
+    raw: UnifiedRequest;
+    method: string;
+    path: string;
+    url: URL | null;
+    query: QueryParams;
+    params: RequestParams;
+    protocol: string;
+    isHttp2: boolean;
+    body?: TBody;
+    header: (name: string) => string | undefined;
+    headers: (names?: string[]) => Record<string, string | undefined>;
+}
+/**
+ * Context object representing a request/response cycle
+ */
+interface Context<S extends State = State, TBody = unknown, TQuery = QueryParams> {
+    /**
+     * Request information
+     */
+    request: Omit<ContextRequest, 'body' | 'query'> & {
+        body: TBody;
+        query: TQuery;
+    };
+    /**
+     * Response handling
+     */
+    response: ContextResponse<S>;
+    /**
+     * Request-scoped state for storing data during the request lifecycle
+     */
+    state: S;
+}
+/**
+ * Options for creating a context
+ */
+interface ContextOptions {
+    /**
+     * Whether to parse the request body
+     */
+    parseBody?: boolean;
+    /**
+     * Additional state to merge into the context
+     */
+    initialState?: State;
+}
+/**
+ * Function to get the current context from AsyncLocalStorage
+ */
+type GetContextFn = <S extends State = State>() => Context<S> | undefined;
+/**
+ * Factory function for creating a new context
+ */
+type CreateContextFn = (req: UnifiedRequest, res: UnifiedResponse, options?: ContextOptions) => Promise<Context>;
+/**
+ * Type representing unknown function
+ *
+ * This is a generic function type that can accept any number of arguments
+ * and return any type of value. It is used for type inference in various
+ * contexts where the specific function signature is not known or not
+ * important.
+ */
+type UnknownFunction = (...args: unknown[]) => unknown;
+
+/**
+ * Function to pass control to the next middleware
+ */
+type NextFunction = () => Promise<void> | void;
+/**
+ * Middleware function signature
+ */
+type MiddlewareFunction = (ctx: Context, next: NextFunction) => Promise<void> | void;
+/**
+ * Named middleware options
+ */
+interface MiddlewareOptions {
+    /** Name of the middleware for debugging and logging */
+    name?: string;
+    /** The middleware handler function */
+    handler: MiddlewareFunction;
+    /** Skip function to conditionally bypass middleware */
+    skip?: ((ctx: Context) => boolean) | undefined;
+    /** Enable debugging for this middleware */
+    debug?: boolean;
+}
+/**
+ * Middleware type
+ */
+interface Middleware {
+    name: string;
+    execute: MiddlewareFunction;
+    skip?: ((ctx: Context) => boolean) | undefined;
+    debug?: boolean | undefined;
+}
+
+/**
+ * Helper type to extract TypeScript type from Zod schema
+ */
+type Infer<T> = T extends z.ZodType<infer R> ? R : unknown;
+/**
+ * HTTP methods supported by the router
+ */
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
+/**
+ * Schema for route validation with generic type parameters
+ */
+interface RouteSchema<P extends z.ZodType = z.ZodType<any>, Q extends z.ZodType = z.ZodType<any>, B extends z.ZodType = z.ZodType<any>, R extends z.ZodType = z.ZodType<any>> {
+    /** Parameter schema for validation */
+    params?: P;
+    /** Query schema for validation */
+    query?: Q;
+    /** Body schema for validation */
+    body?: B;
+    /** Response schema for validation */
+    response?: R;
+}
+/**
+ * Route handler function with strongly typed params and response
+ */
+type RouteHandler<TParams = Record<string, string>, TQuery = Record<string, string | string[] | undefined>, TBody = unknown, TResponse = unknown> = (ctx: Context<State, TBody, TQuery>, params: TParams) => Promise<TResponse> | TResponse;
+/**
+ * Options for a route method with schema-based type inference
+ */
+interface RouteMethodOptions<P extends z.ZodType = z.ZodType<any>, Q extends z.ZodType = z.ZodType<any>, B extends z.ZodType = z.ZodType<any>, R extends z.ZodType = z.ZodType<any>> {
+    /** Schema for request/response validation */
+    schema?: RouteSchema<P, Q, B, R>;
+    /** Handler function for the route */
+    handler: RouteHandler<P extends z.ZodType ? Infer<P> : Record<string, string>, Q extends z.ZodType ? Infer<Q> : QueryParams, B extends z.ZodType ? Infer<B> : unknown, R extends z.ZodType ? Infer<R> : unknown>;
+    /** Middleware to apply to this route */
+    middleware?: Middleware[];
+    /** Route-specific options */
+    options?: Record<string, unknown>;
+}
+/**
+ * Route definition mapping HTTP methods to handlers
+ */
+interface RouteDefinition {
+    GET?: RouteMethodOptions<any, any, never, any>;
+    POST?: RouteMethodOptions<any, any, any, any>;
+    PUT?: RouteMethodOptions<any, any, any, any>;
+    DELETE?: RouteMethodOptions<any, any, never, any>;
+    PATCH?: RouteMethodOptions<any, any, any, any>;
+    HEAD?: RouteMethodOptions<any, any, never, any>;
+    OPTIONS?: RouteMethodOptions<any, any, never, any>;
+}
+/**
+ * Route object with path
+ */
+interface Route extends RouteDefinition {
+    /** Path of the route */
+    path: string;
+}
+/**
+ * Options for route creation
+ */
+interface RouteOptions {
+    /** Base path for the route */
+    basePath?: string;
+}
+/**
+ * Result type for handling success and error responses
+ */
+type Result<T, E = {
+    error: string;
+    message: string;
+    details?: unknown;
+}> = {
+    success: true;
+    data: T;
+    status?: number;
+} | {
+    success: false;
+    error: E;
+    status?: number;
+};
+/**
+ * Router options
+ */
+interface RouterOptions {
+    /** Directory containing route files */
+    routesDir: string;
+    /** Base path for all routes */
+    basePath?: string;
+    /** Watch for file changes in development */
+    watchMode?: boolean;
+}
+/**
+ * Router interface
+ */
+interface Router {
+    /** Handle an incoming request */
+    handleRequest: (ctx: Context) => Promise<void>;
+    /** Get all registered routes */
+    getRoutes: () => Route[];
+    /** Add a route programmatically */
+    addRoute: (route: Route) => void;
+    /** Add multiple routes programmatically with batch processing */
+    addRoutes: (routes: Route[]) => {
+        added: Route[];
+        removed: string[];
+        changed: Route[];
+    };
+    /** Add a route directory for plugins */
+    addRouteDirectory(directory: string, options?: {
+        prefix?: string;
+    }): Promise<void>;
+    /** Get route conflicts */
+    getRouteConflicts(): Array<{
+        path: string;
+        sources: string[];
+    }>;
+    /** Close watchers and cleanup resources */
+    close?: () => Promise<void>;
+}
+/**
+ * Route match result
+ */
+interface RouteMatch {
+    /** The matched route handler (null if method not allowed) */
+    route: RouteMethodOptions | null;
+    /** Extracted route parameters */
+    params: Record<string, string>;
+    /** Flag indicating if the path exists but method isn't allowed */
+    methodNotAllowed?: boolean;
+    /** List of allowed methods for this path (when method not allowed) */
+    allowedMethods?: HttpMethod[];
+}
+/**
+ * Route matcher interface
+ */
+interface Matcher {
+    /** Add a route to the matcher */
+    add: (path: string, method: HttpMethod, route: RouteMethodOptions) => void;
+    /** Match a URL path to a route */
+    match: (path: string, method: HttpMethod) => RouteMatch | null;
+    /** Get all registered routes */
+    getRoutes: () => {
+        path: string;
+        method: HttpMethod;
+    }[];
+    /** Find routes matching a specific path */
+    findRoutes: (path: string) => {
+        path: string;
+        method: HttpMethod;
+        params: Record<string, string>;
+    }[];
+    /** Remove a route from the matcher (optional for compatibility) */
+    remove: (path: string) => void;
+    /** Clear all routes from the matcher (optional for compatibility) */
+    clear: () => void;
+}
+interface ParsedRoute {
+    filePath: string;
+    routePath: string;
+    params: string[];
+}
+/**
+ * Node in the radix tree for efficient route matching
+ */
+interface RouteNode {
+    segment: string;
+    paramName: string | null;
+    isWildcard: boolean;
+    children: RouteNode[];
+    handlers: Partial<Record<HttpMethod, RouteMethodOptions>>;
+    pattern: RegExp | null;
+}
+interface RouteEntry {
+    /** The route path pattern */
+    path: string;
+    /** The HTTP method */
+    method: HttpMethod;
+    /** The compiled regex pattern */
+    pattern: RegExp;
+    /** The parameter names in order */
+    paramNames: string[];
+    /** The route handler options */
+    routeOptions: RouteMethodOptions;
+}
+interface ErrorHandlerOptions {
+    /** Show detailed errors in response */
+    detailed?: boolean;
+    /** Log errors to console */
+    log?: boolean;
+}
+interface ProcessResponseOptions {
+    /** Status code to use if not specified */
+    defaultStatus?: number;
+}
+/**
+ * Standard error response structure
+ */
+interface StandardErrorResponse {
+    error: string;
+    message: string;
+}
+/**
+ * GET route creator - no body schema needed
+ */
+type CreateGetRoute = <P extends z.ZodType = z.ZodType<any>, Q extends z.ZodType = z.ZodType<any>, R extends z.ZodType = z.ZodType<any>>(config: {
+    schema?: {
+        params?: P;
+        query?: Q;
+        response?: R;
+    };
+    handler: RouteHandler<P extends z.ZodType ? Infer<P> : Record<string, string>, Q extends z.ZodType ? Infer<Q> : QueryParams, never, R extends z.ZodType ? Infer<R> : unknown>;
+    middleware?: Middleware[];
+    options?: Record<string, unknown>;
+}) => {
+    GET: RouteMethodOptions<P, Q, never, R>;
+    path: string;
+};
+/**
+ * POST route creator - includes body schema
+ */
+type CreatePostRoute = <P extends z.ZodType = z.ZodType<any>, Q extends z.ZodType = z.ZodType<any>, B extends z.ZodType = z.ZodType<any>, R extends z.ZodType = z.ZodType<any>>(config: {
+    schema?: {
+        params?: P;
+        query?: Q;
+        body?: B;
+        response?: R;
+    };
+    handler: RouteHandler<P extends z.ZodType ? Infer<P> : Record<string, string>, Q extends z.ZodType ? Infer<Q> : QueryParams, B extends z.ZodType ? Infer<B> : unknown, R extends z.ZodType ? Infer<R> : unknown>;
+    middleware?: Middleware[];
+    options?: Record<string, unknown>;
+}) => {
+    POST: RouteMethodOptions<P, Q, B, R>;
+    path: string;
+};
+/**
+ * PUT route creator - includes body schema
+ */
+type CreatePutRoute = <P extends z.ZodType = z.ZodType<any>, Q extends z.ZodType = z.ZodType<any>, B extends z.ZodType = z.ZodType<any>, R extends z.ZodType = z.ZodType<any>>(config: {
+    schema?: {
+        params?: P;
+        query?: Q;
+        body?: B;
+        response?: R;
+    };
+    handler: RouteHandler<P extends z.ZodType ? Infer<P> : Record<string, string>, Q extends z.ZodType ? Infer<Q> : QueryParams, B extends z.ZodType ? Infer<B> : unknown, R extends z.ZodType ? Infer<R> : unknown>;
+    middleware?: Middleware[];
+    options?: Record<string, unknown>;
+}) => {
+    PUT: RouteMethodOptions<P, Q, B, R>;
+    path: string;
+};
+/**
+ * DELETE route creator - typically no body
+ */
+type CreateDeleteRoute = <P extends z.ZodType = z.ZodType<any>, Q extends z.ZodType = z.ZodType<any>, R extends z.ZodType = z.ZodType<any>>(config: {
+    schema?: {
+        params?: P;
+        query?: Q;
+        response?: R;
+    };
+    handler: RouteHandler<P extends z.ZodType ? Infer<P> : Record<string, string>, Q extends z.ZodType ? Infer<Q> : QueryParams, never, R extends z.ZodType ? Infer<R> : unknown>;
+    middleware?: Middleware[];
+    options?: Record<string, unknown>;
+}) => {
+    DELETE: RouteMethodOptions<P, Q, never, R>;
+    path: string;
+};
+/**
+ * PATCH route creator - includes body schema
+ */
+type CreatePatchRoute = <P extends z.ZodType = z.ZodType<any>, Q extends z.ZodType = z.ZodType<any>, B extends z.ZodType = z.ZodType<any>, R extends z.ZodType = z.ZodType<any>>(config: {
+    schema?: {
+        params?: P;
+        query?: Q;
+        body?: B;
+        response?: R;
+    };
+    handler: RouteHandler<P extends z.ZodType ? Infer<P> : Record<string, string>, Q extends z.ZodType ? Infer<Q> : QueryParams, B extends z.ZodType ? Infer<B> : unknown, R extends z.ZodType ? Infer<R> : unknown>;
+    middleware?: Middleware[];
+    options?: Record<string, unknown>;
+}) => {
+    PATCH: RouteMethodOptions<P, Q, B, R>;
+    path: string;
+};
+/**
+ * HEAD route creator - no body schema needed (same as GET)
+ */
+type CreateHeadRoute = <P extends z.ZodType = z.ZodType<any>, Q extends z.ZodType = z.ZodType<any>, R extends z.ZodType = z.ZodType<any>>(config: {
+    schema?: {
+        params?: P;
+        query?: Q;
+        response?: R;
+    };
+    handler: RouteHandler<P extends z.ZodType ? Infer<P> : Record<string, string>, Q extends z.ZodType ? Infer<Q> : QueryParams, never, R extends z.ZodType ? Infer<R> : unknown>;
+    middleware?: Middleware[];
+    options?: Record<string, unknown>;
+}) => {
+    HEAD: RouteMethodOptions<P, Q, never, R>;
+    path: string;
+};
+/**
+ * OPTIONS route creator - typically no body or response schema
+ */
+type CreateOptionsRoute = <P extends z.ZodType = z.ZodType<any>, Q extends z.ZodType = z.ZodType<any>, R extends z.ZodType = z.ZodType<any>>(config: {
+    schema?: {
+        params?: P;
+        query?: Q;
+        response?: R;
+    };
+    handler: RouteHandler<P extends z.ZodType ? Infer<P> : Record<string, string>, Q extends z.ZodType ? Infer<Q> : QueryParams, never, R extends z.ZodType ? Infer<R> : unknown>;
+    middleware?: Middleware[];
+    options?: Record<string, unknown>;
+}) => {
+    OPTIONS: RouteMethodOptions<P, Q, never, R>;
+    path: string;
+};
+interface FileCache {
+    routes: Route[];
+    timestamp: number;
+    hash: string;
+}
+interface ReloadMetrics {
+    fileChanges: number;
+    totalReloadTime: number;
+    averageReloadTime: number;
+    slowReloads: Array<{
+        file: string;
+        time: number;
+    }>;
+}
+interface WatchOptions {
+    debounceMs?: number;
+    /** Directories to ignore */
+    ignore?: string[];
+    /** Callback for new routes */
+    onRouteAdded?: (filePath: string, routes: Route[]) => void;
+    /** Callback for changed routes */
+    onRouteChanged?: (filePath: string, routes: Route[]) => void;
+    /** Callback for removed routes */
+    onRouteRemoved?: (filePath: string, routes: Route[]) => void;
+    /** Callback for errors */
+    onError?: (error: Error) => void;
+}
+interface RouteRegistry {
+    routesByPath: Map<string, Route>;
+    routesByFile: Map<string, Set<string>>;
+    pathToFile: Map<string, string>;
+}
+
+type ExtractParams<T> = T extends RouteMethodOptions<infer P, any, any, any> ? P extends z.ZodType ? Infer<P> : Record<string, string> : never;
+type ExtractQuery<T> = T extends RouteMethodOptions<any, infer Q, any, any> ? Q extends z.ZodType ? Infer<Q> : Record<string, string | string[] | undefined> : never;
+type ExtractBody<T> = T extends RouteMethodOptions<any, any, infer B, any> ? B extends z.ZodType ? Infer<B> : unknown : never;
+type ExtractResponse<T> = T extends RouteMethodOptions<any, any, any, infer R> ? R extends z.ZodType ? Infer<R> : unknown : never;
+type ExtractMethod<T> = T extends {
+    GET: any;
+} ? 'GET' : T extends {
+    POST: any;
+} ? 'POST' : T extends {
+    PUT: any;
+} ? 'PUT' : T extends {
+    DELETE: any;
+} ? 'DELETE' : T extends {
+    PATCH: any;
+} ? 'PATCH' : T extends {
+    HEAD: any;
+} ? 'HEAD' : T extends {
+    OPTIONS: any;
+} ? 'OPTIONS' : never;
+type BuildRoutesRegistry<TRoutes extends Record<string, any>> = {
+    [Method in ExtractMethod<TRoutes[keyof TRoutes]> as `$${Lowercase<Method>}`]: {
+        [K in keyof TRoutes as ExtractMethod<TRoutes[K]> extends Method ? K : never]: TRoutes[K];
+    };
+};
+type GetRouteMethod<TRoute> = TRoute extends {
+    path: string;
+} ? Omit<TRoute, 'path'>[keyof Omit<TRoute, 'path'>] : never;
+type CreateClientMethod<TRoute> = GetRouteMethod<TRoute> extends RouteMethodOptions<any, any, any, any> ? (args?: {
+    params?: ExtractParams<GetRouteMethod<TRoute>>;
+    query?: ExtractQuery<GetRouteMethod<TRoute>>;
+    body?: ExtractBody<GetRouteMethod<TRoute>>;
+}) => Promise<ExtractResponse<GetRouteMethod<TRoute>>> : never;
+type CreateClient<TRoutes extends Record<string, Record<string, any>>> = {
+    [Method in keyof TRoutes]: {
+        [RouteName in keyof TRoutes[Method]]: CreateClientMethod<TRoutes[Method][RouteName]>;
+    };
+};
+interface ClientConfig {
+    baseUrl: string;
+    defaultHeaders?: Record<string, string>;
+    timeout?: number;
+}
+interface RequestArgs {
+    params?: Record<string, string>;
+    query?: Record<string, any>;
+    body?: unknown;
+}
+interface RequestOptions {
+    method: string;
+    url: string;
+    headers: Record<string, string>;
+    body?: string;
+    timeout: number;
+}
+
+/**
+ * BlaizeJS Plugin Module
+ *
+ * Provides the plugin system for extending framework functionality.
+ */
+
+/**
+ * Plugin options
+ */
+interface PluginOptions<_T = any> {
+    /** Plugin configuration */
+    [key: string]: any;
+}
+/**
+ * Plugin lifecycle hooks
+ */
+interface PluginHooks {
+    /** Called when the plugin is registered */
+    register: (app: Server) => void | Promise<void>;
+    /** Called when the server is initialized */
+    initialize?: (app?: Server) => void | Promise<void>;
+    /** Called when the server is terminated */
+    terminate?: (app?: Server) => void | Promise<void>;
+    /** Called when the server starts */
+    onServerStart?: (server: any) => void | Promise<void>;
+    /** Called when the server stops */
+    onServerStop?: (server: any) => void | Promise<void>;
+}
+/**
+ * Plugin interface
+ */
+interface Plugin extends PluginHooks {
+    /** Plugin name */
+    name: string;
+    /** Plugin version */
+    version: string;
+}
+/**
+ * Plugin factory function
+ */
+type PluginFactory<T = any> = (options?: T) => Plugin;
+interface PluginLifecycleManager {
+    initializePlugins(server: Server): Promise<void>;
+    terminatePlugins(server: Server): Promise<void>;
+    onServerStart(server: Server, httpServer: any): Promise<void>;
+    onServerStop(server: Server, httpServer: any): Promise<void>;
+}
+interface PluginLifecycleOptions {
+    /** Continue initialization even if a plugin fails */
+    continueOnError?: boolean;
+    /** Log plugin lifecycle events */
+    debug?: boolean;
+    /** Custom error handler for plugin failures */
+    onError?: (plugin: Plugin, phase: string, error: Error) => void;
+}
+
+/**
+ * BlaizeJS Server Module
+ *
+ * Provides the core HTTP/2 server implementation with HTTP/1.1 fallback.
+ */
+
+interface Http2Options {
+    enabled?: boolean | undefined;
+    keyFile?: string | undefined;
+    certFile?: string | undefined;
+}
+interface StartOptions {
+    port?: number;
+    host?: string;
+}
+interface StopOptions {
+    timeout?: number;
+    plugins?: Plugin[];
+    onStopping?: () => Promise<void> | void;
+    onStopped?: () => Promise<void> | void;
+}
+/**
+ * Server options for configuring the BlaizeJS server
+ */
+interface ServerOptionsInput {
+    /** Port to listen on (default: 3000) */
+    port?: number;
+    /** Host to bind to (default: localhost) */
+    host?: string;
+    /** Directory containing route files (default: ./routes) */
+    routesDir?: string;
+    /** HTTP/2 options */
+    http2?: {
+        /** Enable HTTP/2 (default: true) */
+        enabled?: boolean | undefined;
+        /** Path to key file for HTTPS/HTTP2 */
+        keyFile?: string | undefined;
+        /** Path to certificate file for HTTPS/HTTP2 */
+        certFile?: string | undefined;
+    };
+    /** Global middleware to apply to all routes */
+    middleware?: Middleware[];
+    /** Plugins to register */
+    plugins?: Plugin[];
+}
+/**
+ * Configuration for a BlaizeJS server
+ */
+interface ServerOptions {
+    /** Port to listen on (default: 3000) */
+    port: number;
+    /** Host to bind to (default: localhost) */
+    host: string;
+    /** Directory containing route files (default: ./routes) */
+    routesDir: string;
+    /** HTTP/2 options */
+    http2?: {
+        /** Enable HTTP/2 (default: true) */
+        enabled?: boolean | undefined;
+        /** Path to key file for HTTPS/HTTP2 */
+        keyFile?: string | undefined;
+        /** Path to certificate file for HTTPS/HTTP2 */
+        certFile?: string | undefined;
+    };
+    /** Global middleware to apply to all routes */
+    middleware?: Middleware[];
+    /** Plugins to register */
+    plugins?: Plugin[];
+}
+/**
+ * BlaizeJS Server instance
+ */
+interface Server {
+    /** The underlying HTTP or HTTP/2 server */
+    server: http.Server | http2.Http2Server | undefined;
+    /** The port the server is configured to listen on */
+    port: number;
+    /** The host the server is bound to */
+    host: string;
+    events: EventEmitter;
+    /** Direct access to registered plugins */
+    plugins: Plugin[];
+    /** Direct access to registered plugins */
+    middleware: Middleware[];
+    /** Internal property for signal hanlders */
+    _signalHandlers?: {
+        unregister: () => void;
+    };
+    /** Start the server and listen for connections */
+    listen: (port?: number, host?: string) => Promise<Server>;
+    /** Stop the server */
+    close: (stopOptions?: StopOptions) => Promise<void>;
+    /** Add global middleware */
+    use: (middleware: Middleware | Middleware[]) => Server;
+    /** Register a plugin */
+    register: (plugin: Plugin) => Promise<Server>;
+    /** Access to the routing system */
+    router: Router;
+    /** Context storage system */
+    context: AsyncLocalStorage<Context>;
+    pluginManager: PluginLifecycleManager;
+}
+type RequestHandler = (req: http.IncomingMessage | http2.Http2ServerRequest, res: http.ServerResponse | http2.Http2ServerResponse) => Promise<void>;
+
 declare const VERSION = "0.1.0";
 declare const ServerAPI: {
     createServer: typeof create;
 };
 declare const RouterAPI: {
-    createDeleteRoute: _blaizejs_types.CreateDeleteRoute;
-    createGetRoute: _blaizejs_types.CreateGetRoute;
-    createHeadRoute: _blaizejs_types.CreateHeadRoute;
-    createOptionsRoute: _blaizejs_types.CreateOptionsRoute;
-    createPatchRoute: _blaizejs_types.CreatePatchRoute;
-    createPostRoute: _blaizejs_types.CreatePostRoute;
-    createPutRoute: _blaizejs_types.CreatePutRoute;
+    createDeleteRoute: CreateDeleteRoute;
+    createGetRoute: CreateGetRoute;
+    createHeadRoute: CreateHeadRoute;
+    createOptionsRoute: CreateOptionsRoute;
+    createPatchRoute: CreatePatchRoute;
+    createPostRoute: CreatePostRoute;
+    createPutRoute: CreatePutRoute;
 };
 declare const MiddlewareAPI: {
     createMiddleware: typeof create$2;
@@ -79,13 +788,13 @@ declare const Blaize: {
         createServer: typeof create;
     };
     Router: {
-        createDeleteRoute: _blaizejs_types.CreateDeleteRoute;
-        createGetRoute: _blaizejs_types.CreateGetRoute;
-        createHeadRoute: _blaizejs_types.CreateHeadRoute;
-        createOptionsRoute: _blaizejs_types.CreateOptionsRoute;
-        createPatchRoute: _blaizejs_types.CreatePatchRoute;
-        createPostRoute: _blaizejs_types.CreatePostRoute;
-        createPutRoute: _blaizejs_types.CreatePutRoute;
+        createDeleteRoute: CreateDeleteRoute;
+        createGetRoute: CreateGetRoute;
+        createHeadRoute: CreateHeadRoute;
+        createOptionsRoute: CreateOptionsRoute;
+        createPatchRoute: CreatePatchRoute;
+        createPostRoute: CreatePostRoute;
+        createPutRoute: CreatePutRoute;
     };
     Middleware: {
         createMiddleware: typeof create$2;
@@ -97,4 +806,4 @@ declare const Blaize: {
     VERSION: string;
 };
 
-export { Blaize, MiddlewareAPI, PluginsAPI, RouterAPI, ServerAPI, VERSION, compose, createDeleteRoute, createGetRoute, createHeadRoute, create$2 as createMiddleware, createOptionsRoute, createPatchRoute, create$1 as createPlugin, createPostRoute, createPutRoute, create as createServer, Blaize as default };
+export { Blaize, type BuildRoutesRegistry, type ClientConfig, type Context, type ContextOptions, type ContextRequest, type ContextResponse, type CreateClient, type CreateContextFn, type CreateDeleteRoute, type CreateGetRoute, type CreateHeadRoute, type CreateOptionsRoute, type CreatePatchRoute, type CreatePostRoute, type CreatePutRoute, type ErrorHandlerOptions, type ExtractBody, type ExtractMethod, type ExtractParams, type ExtractQuery, type ExtractResponse, type FileCache, type GetContextFn, type Http2Options, type HttpMethod, type Infer, type Matcher, type Middleware, MiddlewareAPI, type MiddlewareFunction, type MiddlewareOptions, type NextFunction, type ParsedRoute, type Plugin, type PluginFactory, type PluginHooks, type PluginLifecycleManager, type PluginLifecycleOptions, type PluginOptions, PluginsAPI, type ProcessResponseOptions, type QueryParams, type ReloadMetrics, type RequestArgs, type RequestHandler, type RequestOptions, type RequestParams, type Result, type Route, type RouteDefinition, type RouteEntry, type RouteHandler, type RouteMatch, type RouteMethodOptions, type RouteNode, type RouteOptions, type RouteRegistry, type RouteSchema, type Router, RouterAPI, type RouterOptions, type Server, ServerAPI, type ServerOptions, type ServerOptionsInput, type StandardErrorResponse, type StartOptions, type State, type StopOptions, type StreamOptions, type UnifiedRequest, type UnifiedResponse, type UnknownFunction, VERSION, type WatchOptions, compose, createDeleteRoute, createGetRoute, createHeadRoute, create$2 as createMiddleware, createOptionsRoute, createPatchRoute, create$1 as createPlugin, createPostRoute, createPutRoute, create as createServer, Blaize as default };